projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath10k: make hw roc more reliable
[deliverable/linux.git] / drivers / net / wireless / ath / ath10k / mac.c
CommitLineData
5e3dd157
KV		 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
8cd13cad 23#include "hif.h"
5e3dd157
KV		 24#include "core.h"
25#include "debug.h"
26#include "wmi.h"
27#include "htt.h"
28#include "txrx.h"
43d2a30f 29#include "testmode.h"
5e3dd157
KV		 30
31/**********/
32/* Crypto */
33/**********/
34
35static int ath10k_send_key(struct ath10k_vif *arvif,
36 struct ieee80211_key_conf *key,
37 enum set_key_cmd cmd,
38 const u8 *macaddr)
39{
7aa7a72a 40 struct ath10k *ar = arvif->ar;
5e3dd157
KV		 41 struct wmi_vdev_install_key_arg arg = {
42 .vdev_id = arvif->vdev_id,
43 .key_idx = key->keyidx,
44 .key_len = key->keylen,
45 .key_data = key->key,
46 .macaddr = macaddr,
47 };
48
548db54c
MK		 49 lockdep_assert_held(&arvif->ar->conf_mutex);
50
5e3dd157
KV		 51 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
52 arg.key_flags = WMI_KEY_PAIRWISE;
53 else
54 arg.key_flags = WMI_KEY_GROUP;
55
56 switch (key->cipher) {
57 case WLAN_CIPHER_SUITE_CCMP:
58 arg.key_cipher = WMI_CIPHER_AES_CCM;
eeab266c
MK		 59 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
60 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
61 else
62 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
5e3dd157
KV		 63 break;
64 case WLAN_CIPHER_SUITE_TKIP:
5e3dd157
KV		 65 arg.key_cipher = WMI_CIPHER_TKIP;
66 arg.key_txmic_len = 8;
67 arg.key_rxmic_len = 8;
68 break;
69 case WLAN_CIPHER_SUITE_WEP40:
70 case WLAN_CIPHER_SUITE_WEP104:
71 arg.key_cipher = WMI_CIPHER_WEP;
72 /* AP/IBSS mode requires self-key to be groupwise
73 * Otherwise pairwise key must be set */
74 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
75 arg.key_flags = WMI_KEY_PAIRWISE;
76 break;
77 default:
7aa7a72a 78 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
5e3dd157
KV		 79 return -EOPNOTSUPP;
80 }
81
82 if (cmd == DISABLE_KEY) {
83 arg.key_cipher = WMI_CIPHER_NONE;
84 arg.key_data = NULL;
85 }
86
87 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
88}
89
90static int ath10k_install_key(struct ath10k_vif *arvif,
91 struct ieee80211_key_conf *key,
92 enum set_key_cmd cmd,
93 const u8 *macaddr)
94{
95 struct ath10k *ar = arvif->ar;
96 int ret;
97
548db54c
MK		 98 lockdep_assert_held(&ar->conf_mutex);
99
16735d02 100 reinit_completion(&ar->install_key_done);
5e3dd157
KV		 101
102 ret = ath10k_send_key(arvif, key, cmd, macaddr);
103 if (ret)
104 return ret;
105
106 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
107 if (ret == 0)
108 return -ETIMEDOUT;
109
110 return 0;
111}
112
113static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
114 const u8 *addr)
115{
116 struct ath10k *ar = arvif->ar;
117 struct ath10k_peer *peer;
118 int ret;
119 int i;
120
121 lockdep_assert_held(&ar->conf_mutex);
122
123 spin_lock_bh(&ar->data_lock);
124 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
125 spin_unlock_bh(&ar->data_lock);
126
127 if (!peer)
128 return -ENOENT;
129
130 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
131 if (arvif->wep_keys[i] == NULL)
132 continue;
133
134 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
135 addr);
136 if (ret)
137 return ret;
138
139 peer->keys[i] = arvif->wep_keys[i];
140 }
141
142 return 0;
143}
144
145static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
146 const u8 *addr)
147{
148 struct ath10k *ar = arvif->ar;
149 struct ath10k_peer *peer;
150 int first_errno = 0;
151 int ret;
152 int i;
153
154 lockdep_assert_held(&ar->conf_mutex);
155
156 spin_lock_bh(&ar->data_lock);
157 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
158 spin_unlock_bh(&ar->data_lock);
159
160 if (!peer)
161 return -ENOENT;
162
163 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
164 if (peer->keys[i] == NULL)
165 continue;
166
167 ret = ath10k_install_key(arvif, peer->keys[i],
168 DISABLE_KEY, addr);
169 if (ret && first_errno == 0)
170 first_errno = ret;
171
172 if (ret)
7aa7a72a 173 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
5e3dd157
KV		 174 i, ret);
175
176 peer->keys[i] = NULL;
177 }
178
179 return first_errno;
180}
181
182static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
183 struct ieee80211_key_conf *key)
184{
185 struct ath10k *ar = arvif->ar;
186 struct ath10k_peer *peer;
187 u8 addr[ETH_ALEN];
188 int first_errno = 0;
189 int ret;
190 int i;
191
192 lockdep_assert_held(&ar->conf_mutex);
193
194 for (;;) {
195 /* since ath10k_install_key we can't hold data_lock all the
196 * time, so we try to remove the keys incrementally */
197 spin_lock_bh(&ar->data_lock);
198 i = 0;
199 list_for_each_entry(peer, &ar->peers, list) {
200 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
201 if (peer->keys[i] == key) {
b25f32cb 202 ether_addr_copy(addr, peer->addr);
5e3dd157
KV		 203 peer->keys[i] = NULL;
204 break;
205 }
206 }
207
208 if (i < ARRAY_SIZE(peer->keys))
209 break;
210 }
211 spin_unlock_bh(&ar->data_lock);
212
213 if (i == ARRAY_SIZE(peer->keys))
214 break;
215
216 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
217 if (ret && first_errno == 0)
218 first_errno = ret;
219
220 if (ret)
7aa7a72a 221 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
be6546fc 222 addr, ret);
5e3dd157
KV		 223 }
224
225 return first_errno;
226}
227
5e3dd157
KV		 228/*********************/
229/* General utilities */
230/*********************/
231
232static inline enum wmi_phy_mode
233chan_to_phymode(const struct cfg80211_chan_def *chandef)
234{
235 enum wmi_phy_mode phymode = MODE_UNKNOWN;
236
237 switch (chandef->chan->band) {
238 case IEEE80211_BAND_2GHZ:
239 switch (chandef->width) {
240 case NL80211_CHAN_WIDTH_20_NOHT:
241 phymode = MODE_11G;
242 break;
243 case NL80211_CHAN_WIDTH_20:
244 phymode = MODE_11NG_HT20;
245 break;
246 case NL80211_CHAN_WIDTH_40:
247 phymode = MODE_11NG_HT40;
248 break;
0f817ed5
JL		 249 case NL80211_CHAN_WIDTH_5:
250 case NL80211_CHAN_WIDTH_10:
5e3dd157
KV		 251 case NL80211_CHAN_WIDTH_80:
252 case NL80211_CHAN_WIDTH_80P80:
253 case NL80211_CHAN_WIDTH_160:
254 phymode = MODE_UNKNOWN;
255 break;
256 }
257 break;
258 case IEEE80211_BAND_5GHZ:
259 switch (chandef->width) {
260 case NL80211_CHAN_WIDTH_20_NOHT:
261 phymode = MODE_11A;
262 break;
263 case NL80211_CHAN_WIDTH_20:
264 phymode = MODE_11NA_HT20;
265 break;
266 case NL80211_CHAN_WIDTH_40:
267 phymode = MODE_11NA_HT40;
268 break;
269 case NL80211_CHAN_WIDTH_80:
270 phymode = MODE_11AC_VHT80;
271 break;
0f817ed5
JL		 272 case NL80211_CHAN_WIDTH_5:
273 case NL80211_CHAN_WIDTH_10:
5e3dd157
KV		 274 case NL80211_CHAN_WIDTH_80P80:
275 case NL80211_CHAN_WIDTH_160:
276 phymode = MODE_UNKNOWN;
277 break;
278 }
279 break;
280 default:
281 break;
282 }
283
284 WARN_ON(phymode == MODE_UNKNOWN);
285 return phymode;
286}
287
288static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
289{
290/*
291 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
292 * 0 for no restriction
293 * 1 for 1/4 us
294 * 2 for 1/2 us
295 * 3 for 1 us
296 * 4 for 2 us
297 * 5 for 4 us
298 * 6 for 8 us
299 * 7 for 16 us
300 */
301 switch (mpdudensity) {
302 case 0:
303 return 0;
304 case 1:
305 case 2:
306 case 3:
307 /* Our lower layer calculations limit our precision to
308 1 microsecond */
309 return 1;
310 case 4:
311 return 2;
312 case 5:
313 return 4;
314 case 6:
315 return 8;
316 case 7:
317 return 16;
318 default:
319 return 0;
320 }
321}
322
323static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
324{
325 int ret;
326
327 lockdep_assert_held(&ar->conf_mutex);
328
329 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
479398b0 330 if (ret) {
7aa7a72a 331 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
69244e56 332 addr, vdev_id, ret);
5e3dd157 333 return ret;
479398b0 334 }
5e3dd157
KV		 335
336 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
479398b0 337 if (ret) {
7aa7a72a 338 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
69244e56 339 addr, vdev_id, ret);
5e3dd157 340 return ret;
479398b0 341 }
0e759f36
BM		 342 spin_lock_bh(&ar->data_lock);
343 ar->num_peers++;
344 spin_unlock_bh(&ar->data_lock);
5e3dd157
KV		 345
346 return 0;
347}
348
5a13e76e
KV		 349static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
350{
351 struct ath10k *ar = arvif->ar;
352 u32 param;
353 int ret;
354
355 param = ar->wmi.pdev_param->sta_kickout_th;
356 ret = ath10k_wmi_pdev_set_param(ar, param,
357 ATH10K_KICKOUT_THRESHOLD);
358 if (ret) {
7aa7a72a 359 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
69244e56 360 arvif->vdev_id, ret);
5a13e76e
KV		 361 return ret;
362 }
363
364 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
365 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
366 ATH10K_KEEPALIVE_MIN_IDLE);
367 if (ret) {
7aa7a72a 368 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
69244e56 369 arvif->vdev_id, ret);
5a13e76e
KV		 370 return ret;
371 }
372
373 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
374 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
375 ATH10K_KEEPALIVE_MAX_IDLE);
376 if (ret) {
7aa7a72a 377 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
69244e56 378 arvif->vdev_id, ret);
5a13e76e
KV		 379 return ret;
380 }
381
382 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
383 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
384 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
385 if (ret) {
7aa7a72a 386 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
69244e56 387 arvif->vdev_id, ret);
5a13e76e
KV		 388 return ret;
389 }
390
391 return 0;
392}
393
424121c3
MK		 394static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
395{
6d1506e7
BM		 396 struct ath10k *ar = arvif->ar;
397 u32 vdev_param;
398
424121c3
MK		 399 if (value != 0xFFFFFFFF)
400 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
401 ATH10K_RTS_MAX);
402
6d1506e7
BM		 403 vdev_param = ar->wmi.vdev_param->rts_threshold;
404 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
424121c3
MK		 405}
406
407static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
408{
6d1506e7
BM		 409 struct ath10k *ar = arvif->ar;
410 u32 vdev_param;
411
424121c3
MK		 412 if (value != 0xFFFFFFFF)
413 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
414 ATH10K_FRAGMT_THRESHOLD_MIN,
415 ATH10K_FRAGMT_THRESHOLD_MAX);
416
6d1506e7
BM		 417 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
418 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
424121c3
MK		 419}
420
5e3dd157
KV		 421static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
422{
423 int ret;
424
425 lockdep_assert_held(&ar->conf_mutex);
426
427 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
428 if (ret)
429 return ret;
430
431 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
432 if (ret)
433 return ret;
434
0e759f36
BM		 435 spin_lock_bh(&ar->data_lock);
436 ar->num_peers--;
437 spin_unlock_bh(&ar->data_lock);
438
5e3dd157
KV		 439 return 0;
440}
441
442static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
443{
444 struct ath10k_peer *peer, *tmp;
445
446 lockdep_assert_held(&ar->conf_mutex);
447
448 spin_lock_bh(&ar->data_lock);
449 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
450 if (peer->vdev_id != vdev_id)
451 continue;
452
7aa7a72a 453 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
5e3dd157
KV		 454 peer->addr, vdev_id);
455
456 list_del(&peer->list);
457 kfree(peer);
0e759f36 458 ar->num_peers--;
5e3dd157
KV		 459 }
460 spin_unlock_bh(&ar->data_lock);
461}
462
a96d7745
MK		 463static void ath10k_peer_cleanup_all(struct ath10k *ar)
464{
465 struct ath10k_peer *peer, *tmp;
466
467 lockdep_assert_held(&ar->conf_mutex);
468
469 spin_lock_bh(&ar->data_lock);
470 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
471 list_del(&peer->list);
472 kfree(peer);
473 }
0e759f36 474 ar->num_peers = 0;
a96d7745
MK		 475 spin_unlock_bh(&ar->data_lock);
476}
477
5e3dd157
KV		 478/************************/
479/* Interface management */
480/************************/
481
64badcb6
MK		 482void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
483{
484 struct ath10k *ar = arvif->ar;
485
486 lockdep_assert_held(&ar->data_lock);
487
488 if (!arvif->beacon)
489 return;
490
491 if (!arvif->beacon_buf)
492 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
493 arvif->beacon->len, DMA_TO_DEVICE);
494
495 dev_kfree_skb_any(arvif->beacon);
496
497 arvif->beacon = NULL;
498 arvif->beacon_sent = false;
499}
500
501static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
502{
503 struct ath10k *ar = arvif->ar;
504
505 lockdep_assert_held(&ar->data_lock);
506
507 ath10k_mac_vif_beacon_free(arvif);
508
509 if (arvif->beacon_buf) {
510 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
511 arvif->beacon_buf, arvif->beacon_paddr);
512 arvif->beacon_buf = NULL;
513 }
514}
515
5e3dd157
KV		 516static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
517{
518 int ret;
519
548db54c
MK		 520 lockdep_assert_held(&ar->conf_mutex);
521
7962b0d8
MK		 522 if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
523 return -ESHUTDOWN;
524
5e3dd157
KV		 525 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
526 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
527 if (ret == 0)
528 return -ETIMEDOUT;
529
530 return 0;
531}
532
1bbc0975 533static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
5e3dd157 534{
c930f744
MK		 535 struct cfg80211_chan_def *chandef = &ar->chandef;
536 struct ieee80211_channel *channel = chandef->chan;
5e3dd157 537 struct wmi_vdev_start_request_arg arg = {};
5e3dd157
KV		 538 int ret = 0;
539
540 lockdep_assert_held(&ar->conf_mutex);
541
5e3dd157
KV		 542 arg.vdev_id = vdev_id;
543 arg.channel.freq = channel->center_freq;
c930f744 544 arg.channel.band_center_freq1 = chandef->center_freq1;
5e3dd157
KV		 545
546 /* TODO setup this dynamically, what in case we
547 don't have any vifs? */
c930f744 548 arg.channel.mode = chan_to_phymode(chandef);
e8a50f8b
MP		 549 arg.channel.chan_radar =
550 !!(channel->flags & IEEE80211_CHAN_RADAR);
5e3dd157 551
89c5c843 552 arg.channel.min_power = 0;
02256930
MK		 553 arg.channel.max_power = channel->max_power * 2;
554 arg.channel.max_reg_power = channel->max_reg_power * 2;
555 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
5e3dd157 556
7962b0d8
MK		 557 reinit_completion(&ar->vdev_setup_done);
558
5e3dd157
KV		 559 ret = ath10k_wmi_vdev_start(ar, &arg);
560 if (ret) {
7aa7a72a 561 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
69244e56 562 vdev_id, ret);
5e3dd157
KV		 563 return ret;
564 }
565
566 ret = ath10k_vdev_setup_sync(ar);
567 if (ret) {
7aa7a72a 568 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i: %d\n",
69244e56 569 vdev_id, ret);
5e3dd157
KV		 570 return ret;
571 }
572
573 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
574 if (ret) {
7aa7a72a 575 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
69244e56 576 vdev_id, ret);
5e3dd157
KV		 577 goto vdev_stop;
578 }
579
580 ar->monitor_vdev_id = vdev_id;
5e3dd157 581
7aa7a72a 582 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
1bbc0975 583 ar->monitor_vdev_id);
5e3dd157
KV		 584 return 0;
585
586vdev_stop:
587 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
588 if (ret)
7aa7a72a 589 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
69244e56 590 ar->monitor_vdev_id, ret);
5e3dd157
KV		 591
592 return ret;
593}
594
1bbc0975 595static int ath10k_monitor_vdev_stop(struct ath10k *ar)
5e3dd157
KV		 596{
597 int ret = 0;
598
599 lockdep_assert_held(&ar->conf_mutex);
600
52fa0191
MP		 601 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
602 if (ret)
7aa7a72a 603 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
69244e56 604 ar->monitor_vdev_id, ret);
5e3dd157 605
7962b0d8
MK		 606 reinit_completion(&ar->vdev_setup_done);
607
5e3dd157
KV		 608 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
609 if (ret)
7aa7a72a 610 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
69244e56 611 ar->monitor_vdev_id, ret);
5e3dd157
KV		 612
613 ret = ath10k_vdev_setup_sync(ar);
614 if (ret)
7aa7a72a 615 ath10k_warn(ar, "failed to synchronise monitor vdev %i: %d\n",
69244e56 616 ar->monitor_vdev_id, ret);
5e3dd157 617
7aa7a72a 618 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
1bbc0975 619 ar->monitor_vdev_id);
5e3dd157
KV		 620 return ret;
621}
622
1bbc0975 623static int ath10k_monitor_vdev_create(struct ath10k *ar)
5e3dd157
KV		 624{
625 int bit, ret = 0;
626
627 lockdep_assert_held(&ar->conf_mutex);
628
a9aefb3b 629 if (ar->free_vdev_map == 0) {
7aa7a72a 630 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
5e3dd157
KV		 631 return -ENOMEM;
632 }
633
16c11176 634 bit = __ffs64(ar->free_vdev_map);
a9aefb3b 635
16c11176 636 ar->monitor_vdev_id = bit;
5e3dd157
KV		 637
638 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
639 WMI_VDEV_TYPE_MONITOR,
640 0, ar->mac_addr);
641 if (ret) {
7aa7a72a 642 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
69244e56 643 ar->monitor_vdev_id, ret);
a9aefb3b 644 return ret;
5e3dd157
KV		 645 }
646
16c11176 647 ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
7aa7a72a 648 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
5e3dd157
KV		 649 ar->monitor_vdev_id);
650
5e3dd157 651 return 0;
5e3dd157
KV		 652}
653
1bbc0975 654static int ath10k_monitor_vdev_delete(struct ath10k *ar)
5e3dd157
KV		 655{
656 int ret = 0;
657
658 lockdep_assert_held(&ar->conf_mutex);
659
5e3dd157
KV		 660 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
661 if (ret) {
7aa7a72a 662 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
69244e56 663 ar->monitor_vdev_id, ret);
5e3dd157
KV		 664 return ret;
665 }
666
16c11176 667 ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
5e3dd157 668
7aa7a72a 669 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
5e3dd157
KV		 670 ar->monitor_vdev_id);
671 return ret;
672}
673
1bbc0975
MK		 674static int ath10k_monitor_start(struct ath10k *ar)
675{
676 int ret;
677
678 lockdep_assert_held(&ar->conf_mutex);
679
1bbc0975
MK		 680 ret = ath10k_monitor_vdev_create(ar);
681 if (ret) {
7aa7a72a 682 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
1bbc0975
MK		 683 return ret;
684 }
685
686 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
687 if (ret) {
7aa7a72a 688 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1bbc0975
MK		 689 ath10k_monitor_vdev_delete(ar);
690 return ret;
691 }
692
693 ar->monitor_started = true;
7aa7a72a 694 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1bbc0975
MK		 695
696 return 0;
697}
698
1933747f 699static int ath10k_monitor_stop(struct ath10k *ar)
1bbc0975
MK		 700{
701 int ret;
702
703 lockdep_assert_held(&ar->conf_mutex);
704
1bbc0975 705 ret = ath10k_monitor_vdev_stop(ar);
1933747f 706 if (ret) {
7aa7a72a 707 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1933747f
MK		 708 return ret;
709 }
1bbc0975
MK		 710
711 ret = ath10k_monitor_vdev_delete(ar);
1933747f 712 if (ret) {
7aa7a72a 713 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1933747f
MK		 714 return ret;
715 }
1bbc0975
MK		 716
717 ar->monitor_started = false;
7aa7a72a 718 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1933747f
MK		 719
720 return 0;
721}
722
723static int ath10k_monitor_recalc(struct ath10k *ar)
724{
725 bool should_start;
726
727 lockdep_assert_held(&ar->conf_mutex);
728
729 should_start = ar->monitor ||
730 ar->filter_flags & FIF_PROMISC_IN_BSS ||
731 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
732
733 ath10k_dbg(ar, ATH10K_DBG_MAC,
734 "mac monitor recalc started? %d should? %d\n",
735 ar->monitor_started, should_start);
736
737 if (should_start == ar->monitor_started)
738 return 0;
739
740 if (should_start)
741 return ath10k_monitor_start(ar);
d8bb26b9
KV		 742
743 return ath10k_monitor_stop(ar);
1bbc0975
MK		 744}
745
e81bd104
MK		 746static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
747{
748 struct ath10k *ar = arvif->ar;
749 u32 vdev_param, rts_cts = 0;
750
751 lockdep_assert_held(&ar->conf_mutex);
752
753 vdev_param = ar->wmi.vdev_param->enable_rtscts;
754
755 if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
756 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
757
758 if (arvif->num_legacy_stations > 0)
759 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
760 WMI_RTSCTS_PROFILE);
761
762 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
763 rts_cts);
764}
765
e8a50f8b
MP		 766static int ath10k_start_cac(struct ath10k *ar)
767{
768 int ret;
769
770 lockdep_assert_held(&ar->conf_mutex);
771
772 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
773
1933747f 774 ret = ath10k_monitor_recalc(ar);
e8a50f8b 775 if (ret) {
7aa7a72a 776 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
e8a50f8b
MP		 777 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
778 return ret;
779 }
780
7aa7a72a 781 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
e8a50f8b
MP		 782 ar->monitor_vdev_id);
783
784 return 0;
785}
786
787static int ath10k_stop_cac(struct ath10k *ar)
788{
789 lockdep_assert_held(&ar->conf_mutex);
790
791 /* CAC is not running - do nothing */
792 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
793 return 0;
794
e8a50f8b 795 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1bbc0975 796 ath10k_monitor_stop(ar);
e8a50f8b 797
7aa7a72a 798 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
e8a50f8b
MP		 799
800 return 0;
801}
802
d650097b 803static void ath10k_recalc_radar_detection(struct ath10k *ar)
e8a50f8b 804{
e8a50f8b
MP		 805 int ret;
806
807 lockdep_assert_held(&ar->conf_mutex);
808
e8a50f8b
MP		 809 ath10k_stop_cac(ar);
810
d650097b 811 if (!ar->radar_enabled)
e8a50f8b
MP		 812 return;
813
d650097b 814 if (ar->num_started_vdevs > 0)
e8a50f8b
MP		 815 return;
816
817 ret = ath10k_start_cac(ar);
818 if (ret) {
819 /*
820 * Not possible to start CAC on current channel so starting
821 * radiation is not allowed, make this channel DFS_UNAVAILABLE
822 * by indicating that radar was detected.
823 */
7aa7a72a 824 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
e8a50f8b
MP		 825 ieee80211_radar_detected(ar->hw);
826 }
827}
828
dc55e307 829static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, bool restart)
72654fa7
MK		 830{
831 struct ath10k *ar = arvif->ar;
832 struct cfg80211_chan_def *chandef = &ar->chandef;
833 struct wmi_vdev_start_request_arg arg = {};
834 int ret = 0;
835
836 lockdep_assert_held(&ar->conf_mutex);
837
838 reinit_completion(&ar->vdev_setup_done);
839
840 arg.vdev_id = arvif->vdev_id;
841 arg.dtim_period = arvif->dtim_period;
842 arg.bcn_intval = arvif->beacon_interval;
843
844 arg.channel.freq = chandef->chan->center_freq;
845 arg.channel.band_center_freq1 = chandef->center_freq1;
846 arg.channel.mode = chan_to_phymode(chandef);
847
848 arg.channel.min_power = 0;
849 arg.channel.max_power = chandef->chan->max_power * 2;
850 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
851 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
852
853 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
854 arg.ssid = arvif->u.ap.ssid;
855 arg.ssid_len = arvif->u.ap.ssid_len;
856 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
857
858 /* For now allow DFS for AP mode */
859 arg.channel.chan_radar =
860 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
861 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
862 arg.ssid = arvif->vif->bss_conf.ssid;
863 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
864 }
865
7aa7a72a 866 ath10k_dbg(ar, ATH10K_DBG_MAC,
72654fa7
MK		 867 "mac vdev %d start center_freq %d phymode %s\n",
868 arg.vdev_id, arg.channel.freq,
869 ath10k_wmi_phymode_str(arg.channel.mode));
870
dc55e307
MK		 871 if (restart)
872 ret = ath10k_wmi_vdev_restart(ar, &arg);
873 else
874 ret = ath10k_wmi_vdev_start(ar, &arg);
875
72654fa7 876 if (ret) {
7aa7a72a 877 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
72654fa7
MK		 878 arg.vdev_id, ret);
879 return ret;
880 }
881
882 ret = ath10k_vdev_setup_sync(ar);
883 if (ret) {
7aa7a72a 884 ath10k_warn(ar, "failed to synchronise setup for vdev %i: %d\n",
72654fa7
MK		 885 arg.vdev_id, ret);
886 return ret;
887 }
888
d650097b
MK		 889 ar->num_started_vdevs++;
890 ath10k_recalc_radar_detection(ar);
891
72654fa7
MK		 892 return ret;
893}
894
dc55e307
MK		 895static int ath10k_vdev_start(struct ath10k_vif *arvif)
896{
897 return ath10k_vdev_start_restart(arvif, false);
898}
899
900static int ath10k_vdev_restart(struct ath10k_vif *arvif)
901{
902 return ath10k_vdev_start_restart(arvif, true);
903}
904
72654fa7
MK		 905static int ath10k_vdev_stop(struct ath10k_vif *arvif)
906{
907 struct ath10k *ar = arvif->ar;
908 int ret;
909
910 lockdep_assert_held(&ar->conf_mutex);
911
912 reinit_completion(&ar->vdev_setup_done);
913
914 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
915 if (ret) {
7aa7a72a 916 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
72654fa7
MK		 917 arvif->vdev_id, ret);
918 return ret;
919 }
920
921 ret = ath10k_vdev_setup_sync(ar);
922 if (ret) {
7aa7a72a 923 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
72654fa7
MK		 924 arvif->vdev_id, ret);
925 return ret;
926 }
927
d650097b
MK		 928 WARN_ON(ar->num_started_vdevs == 0);
929
930 if (ar->num_started_vdevs != 0) {
931 ar->num_started_vdevs--;
932 ath10k_recalc_radar_detection(ar);
933 }
934
72654fa7
MK		 935 return ret;
936}
937
5e3dd157 938static void ath10k_control_beaconing(struct ath10k_vif *arvif,
5b07e07f 939 struct ieee80211_bss_conf *info)
5e3dd157 940{
7aa7a72a 941 struct ath10k *ar = arvif->ar;
5e3dd157
KV		 942 int ret = 0;
943
548db54c
MK		 944 lockdep_assert_held(&arvif->ar->conf_mutex);
945
5e3dd157
KV		 946 if (!info->enable_beacon) {
947 ath10k_vdev_stop(arvif);
c930f744
MK		 948
949 arvif->is_started = false;
950 arvif->is_up = false;
951
748afc47 952 spin_lock_bh(&arvif->ar->data_lock);
64badcb6 953 ath10k_mac_vif_beacon_free(arvif);
748afc47
MK		 954 spin_unlock_bh(&arvif->ar->data_lock);
955
5e3dd157
KV		 956 return;
957 }
958
959 arvif->tx_seq_no = 0x1000;
960
961 ret = ath10k_vdev_start(arvif);
962 if (ret)
963 return;
964
c930f744 965 arvif->aid = 0;
b25f32cb 966 ether_addr_copy(arvif->bssid, info->bssid);
c930f744
MK		 967
968 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
969 arvif->bssid);
5e3dd157 970 if (ret) {
7aa7a72a 971 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
69244e56 972 arvif->vdev_id, ret);
c930f744 973 ath10k_vdev_stop(arvif);
5e3dd157
KV		 974 return;
975 }
c930f744
MK		 976
977 arvif->is_started = true;
978 arvif->is_up = true;
979
7aa7a72a 980 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
5e3dd157
KV		 981}
982
983static void ath10k_control_ibss(struct ath10k_vif *arvif,
984 struct ieee80211_bss_conf *info,
985 const u8 self_peer[ETH_ALEN])
986{
7aa7a72a 987 struct ath10k *ar = arvif->ar;
6d1506e7 988 u32 vdev_param;
5e3dd157
KV		 989 int ret = 0;
990
548db54c
MK		 991 lockdep_assert_held(&arvif->ar->conf_mutex);
992
5e3dd157
KV		 993 if (!info->ibss_joined) {
994 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
995 if (ret)
7aa7a72a 996 ath10k_warn(ar, "failed to delete IBSS self peer %pM for vdev %d: %d\n",
5e3dd157
KV		 997 self_peer, arvif->vdev_id, ret);
998
c930f744 999 if (is_zero_ether_addr(arvif->bssid))
5e3dd157
KV		 1000 return;
1001
c930f744 1002 memset(arvif->bssid, 0, ETH_ALEN);
5e3dd157
KV		 1003
1004 return;
1005 }
1006
1007 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
1008 if (ret) {
7aa7a72a 1009 ath10k_warn(ar, "failed to create IBSS self peer %pM for vdev %d: %d\n",
5e3dd157
KV		 1010 self_peer, arvif->vdev_id, ret);
1011 return;
1012 }
1013
6d1506e7
BM		 1014 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1015 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 1016 ATH10K_DEFAULT_ATIM);
1017 if (ret)
7aa7a72a 1018 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
5e3dd157
KV		 1019 arvif->vdev_id, ret);
1020}
1021
1022/*
1023 * Review this when mac80211 gains per-interface powersave support.
1024 */
ad088bfa 1025static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
5e3dd157 1026{
ad088bfa
MK		 1027 struct ath10k *ar = arvif->ar;
1028 struct ieee80211_conf *conf = &ar->hw->conf;
5e3dd157
KV		 1029 enum wmi_sta_powersave_param param;
1030 enum wmi_sta_ps_mode psmode;
1031 int ret;
1032
548db54c
MK		 1033 lockdep_assert_held(&arvif->ar->conf_mutex);
1034
ad088bfa
MK		 1035 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1036 return 0;
5e3dd157
KV		 1037
1038 if (conf->flags & IEEE80211_CONF_PS) {
1039 psmode = WMI_STA_PS_MODE_ENABLED;
1040 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1041
ad088bfa 1042 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
5e3dd157
KV		 1043 conf->dynamic_ps_timeout);
1044 if (ret) {
7aa7a72a 1045 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
69244e56 1046 arvif->vdev_id, ret);
ad088bfa 1047 return ret;
5e3dd157 1048 }
5e3dd157
KV		 1049 } else {
1050 psmode = WMI_STA_PS_MODE_DISABLED;
1051 }
1052
7aa7a72a 1053 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
60c3daa8
KV		 1054 arvif->vdev_id, psmode ? "enable" : "disable");
1055
ad088bfa
MK		 1056 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1057 if (ret) {
7aa7a72a 1058 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
be6546fc 1059 psmode, arvif->vdev_id, ret);
ad088bfa
MK		 1060 return ret;
1061 }
1062
1063 return 0;
5e3dd157
KV		 1064}
1065
1066/**********************/
1067/* Station management */
1068/**********************/
1069
590922a8
MK		 1070static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1071 struct ieee80211_vif *vif)
1072{
1073 /* Some firmware revisions have unstable STA powersave when listen
1074 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1075 * generate NullFunc frames properly even if buffered frames have been
1076 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1077 * buffered frames. Often pinging the device from AP would simply fail.
1078 *
1079 * As a workaround set it to 1.
1080 */
1081 if (vif->type == NL80211_IFTYPE_STATION)
1082 return 1;
1083
1084 return ar->hw->conf.listen_interval;
1085}
1086
5e3dd157 1087static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
590922a8 1088 struct ieee80211_vif *vif,
5e3dd157 1089 struct ieee80211_sta *sta,
5e3dd157
KV		 1090 struct wmi_peer_assoc_complete_arg *arg)
1091{
590922a8
MK		 1092 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1093
548db54c
MK		 1094 lockdep_assert_held(&ar->conf_mutex);
1095
b25f32cb 1096 ether_addr_copy(arg->addr, sta->addr);
5e3dd157
KV		 1097 arg->vdev_id = arvif->vdev_id;
1098 arg->peer_aid = sta->aid;
1099 arg->peer_flags |= WMI_PEER_AUTH;
590922a8 1100 arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
5e3dd157 1101 arg->peer_num_spatial_streams = 1;
590922a8 1102 arg->peer_caps = vif->bss_conf.assoc_capability;
5e3dd157
KV		 1103}
1104
1105static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
590922a8 1106 struct ieee80211_vif *vif,
5e3dd157
KV		 1107 struct wmi_peer_assoc_complete_arg *arg)
1108{
5e3dd157
KV		 1109 struct ieee80211_bss_conf *info = &vif->bss_conf;
1110 struct cfg80211_bss *bss;
1111 const u8 *rsnie = NULL;
1112 const u8 *wpaie = NULL;
1113
548db54c
MK		 1114 lockdep_assert_held(&ar->conf_mutex);
1115
5e3dd157
KV		 1116 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1117 info->bssid, NULL, 0, 0, 0);
1118 if (bss) {
1119 const struct cfg80211_bss_ies *ies;
1120
1121 rcu_read_lock();
1122 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1123
1124 ies = rcu_dereference(bss->ies);
1125
1126 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
5b07e07f
KV		 1127 WLAN_OUI_TYPE_MICROSOFT_WPA,
1128 ies->data,
1129 ies->len);
5e3dd157
KV		 1130 rcu_read_unlock();
1131 cfg80211_put_bss(ar->hw->wiphy, bss);
1132 }
1133
1134 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1135 if (rsnie || wpaie) {
7aa7a72a 1136 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
5e3dd157
KV		 1137 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1138 }
1139
1140 if (wpaie) {
7aa7a72a 1141 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
5e3dd157
KV		 1142 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1143 }
1144}
1145
1146static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1147 struct ieee80211_sta *sta,
1148 struct wmi_peer_assoc_complete_arg *arg)
1149{
1150 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1151 const struct ieee80211_supported_band *sband;
1152 const struct ieee80211_rate *rates;
1153 u32 ratemask;
1154 int i;
1155
548db54c
MK		 1156 lockdep_assert_held(&ar->conf_mutex);
1157
5e3dd157
KV		 1158 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1159 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1160 rates = sband->bitrates;
1161
1162 rateset->num_rates = 0;
1163
1164 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1165 if (!(ratemask & 1))
1166 continue;
1167
1168 rateset->rates[rateset->num_rates] = rates->hw_value;
1169 rateset->num_rates++;
1170 }
1171}
1172
1173static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1174 struct ieee80211_sta *sta,
1175 struct wmi_peer_assoc_complete_arg *arg)
1176{
1177 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
5e3dd157 1178 int i, n;
af762c0b 1179 u32 stbc;
5e3dd157 1180
548db54c
MK		 1181 lockdep_assert_held(&ar->conf_mutex);
1182
5e3dd157
KV		 1183 if (!ht_cap->ht_supported)
1184 return;
1185
1186 arg->peer_flags |= WMI_PEER_HT;
1187 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1188 ht_cap->ampdu_factor)) - 1;
1189
1190 arg->peer_mpdu_density =
1191 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1192
1193 arg->peer_ht_caps = ht_cap->cap;
1194 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1195
1196 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1197 arg->peer_flags |= WMI_PEER_LDPC;
1198
1199 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1200 arg->peer_flags |= WMI_PEER_40MHZ;
1201 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1202 }
1203
1204 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1205 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1206
1207 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1208 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1209
1210 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1211 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1212 arg->peer_flags |= WMI_PEER_STBC;
1213 }
1214
1215 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
5e3dd157
KV		 1216 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1217 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1218 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1219 arg->peer_rate_caps |= stbc;
1220 arg->peer_flags |= WMI_PEER_STBC;
1221 }
1222
5e3dd157
KV		 1223 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1224 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1225 else if (ht_cap->mcs.rx_mask[1])
1226 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1227
1228 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1229 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1230 arg->peer_ht_rates.rates[n++] = i;
1231
fd71f807
BM		 1232 /*
1233 * This is a workaround for HT-enabled STAs which break the spec
1234 * and have no HT capabilities RX mask (no HT RX MCS map).
1235 *
1236 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1237 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1238 *
1239 * Firmware asserts if such situation occurs.
1240 */
1241 if (n == 0) {
1242 arg->peer_ht_rates.num_rates = 8;
1243 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1244 arg->peer_ht_rates.rates[i] = i;
1245 } else {
1246 arg->peer_ht_rates.num_rates = n;
1247 arg->peer_num_spatial_streams = sta->rx_nss;
1248 }
5e3dd157 1249
7aa7a72a 1250 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
60c3daa8 1251 arg->addr,
5e3dd157
KV		 1252 arg->peer_ht_rates.num_rates,
1253 arg->peer_num_spatial_streams);
1254}
1255
d3d3ff42
JD		 1256static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1257 struct ath10k_vif *arvif,
1258 struct ieee80211_sta *sta)
5e3dd157
KV		 1259{
1260 u32 uapsd = 0;
1261 u32 max_sp = 0;
d3d3ff42 1262 int ret = 0;
5e3dd157 1263
548db54c
MK		 1264 lockdep_assert_held(&ar->conf_mutex);
1265
5e3dd157 1266 if (sta->wme && sta->uapsd_queues) {
7aa7a72a 1267 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
5e3dd157
KV		 1268 sta->uapsd_queues, sta->max_sp);
1269
5e3dd157
KV		 1270 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1271 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1272 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1273 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1274 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1275 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1276 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1277 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1278 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1279 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1280 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1281 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1282
5e3dd157
KV		 1283 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1284 max_sp = sta->max_sp;
1285
d3d3ff42
JD		 1286 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1287 sta->addr,
1288 WMI_AP_PS_PEER_PARAM_UAPSD,
1289 uapsd);
1290 if (ret) {
7aa7a72a 1291 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
69244e56 1292 arvif->vdev_id, ret);
d3d3ff42
JD		 1293 return ret;
1294 }
5e3dd157 1295
d3d3ff42
JD		 1296 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1297 sta->addr,
1298 WMI_AP_PS_PEER_PARAM_MAX_SP,
1299 max_sp);
1300 if (ret) {
7aa7a72a 1301 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
69244e56 1302 arvif->vdev_id, ret);
d3d3ff42
JD		 1303 return ret;
1304 }
5e3dd157
KV		 1305
1306 /* TODO setup this based on STA listen interval and
1307 beacon interval. Currently we don't know
1308 sta->listen_interval - mac80211 patch required.
1309 Currently use 10 seconds */
d3d3ff42 1310 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
5b07e07f
KV		 1311 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1312 10);
d3d3ff42 1313 if (ret) {
7aa7a72a 1314 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
69244e56 1315 arvif->vdev_id, ret);
d3d3ff42
JD		 1316 return ret;
1317 }
5e3dd157 1318 }
5e3dd157 1319
d3d3ff42 1320 return 0;
5e3dd157
KV		 1321}
1322
1323static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1324 struct ieee80211_sta *sta,
1325 struct wmi_peer_assoc_complete_arg *arg)
1326{
1327 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
a24b88b5 1328 u8 ampdu_factor;
5e3dd157
KV		 1329
1330 if (!vht_cap->vht_supported)
1331 return;
1332
1333 arg->peer_flags |= WMI_PEER_VHT;
5e3dd157
KV		 1334 arg->peer_vht_caps = vht_cap->cap;
1335
a24b88b5
SM		 1336 ampdu_factor = (vht_cap->cap &
1337 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1338 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1339
1340 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1341 * zero in VHT IE. Using it would result in degraded throughput.
1342 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1343 * it if VHT max_mpdu is smaller. */
1344 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1345 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1346 ampdu_factor)) - 1);
1347
5e3dd157
KV		 1348 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1349 arg->peer_flags |= WMI_PEER_80MHZ;
1350
1351 arg->peer_vht_rates.rx_max_rate =
1352 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1353 arg->peer_vht_rates.rx_mcs_set =
1354 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1355 arg->peer_vht_rates.tx_max_rate =
1356 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1357 arg->peer_vht_rates.tx_mcs_set =
1358 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1359
7aa7a72a 1360 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
60c3daa8 1361 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
5e3dd157
KV		 1362}
1363
1364static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
590922a8 1365 struct ieee80211_vif *vif,
5e3dd157 1366 struct ieee80211_sta *sta,
5e3dd157
KV		 1367 struct wmi_peer_assoc_complete_arg *arg)
1368{
590922a8
MK		 1369 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1370
5e3dd157
KV		 1371 switch (arvif->vdev_type) {
1372 case WMI_VDEV_TYPE_AP:
d3d3ff42
JD		 1373 if (sta->wme)
1374 arg->peer_flags |= WMI_PEER_QOS;
1375
1376 if (sta->wme && sta->uapsd_queues) {
1377 arg->peer_flags |= WMI_PEER_APSD;
1378 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1379 }
5e3dd157
KV		 1380 break;
1381 case WMI_VDEV_TYPE_STA:
590922a8 1382 if (vif->bss_conf.qos)
d3d3ff42 1383 arg->peer_flags |= WMI_PEER_QOS;
5e3dd157
KV		 1384 break;
1385 default:
1386 break;
1387 }
1388}
1389
1390static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
590922a8 1391 struct ieee80211_vif *vif,
5e3dd157
KV		 1392 struct ieee80211_sta *sta,
1393 struct wmi_peer_assoc_complete_arg *arg)
1394{
1395 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1396
5e3dd157
KV		 1397 switch (ar->hw->conf.chandef.chan->band) {
1398 case IEEE80211_BAND_2GHZ:
1399 if (sta->ht_cap.ht_supported) {
1400 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1401 phymode = MODE_11NG_HT40;
1402 else
1403 phymode = MODE_11NG_HT20;
1404 } else {
1405 phymode = MODE_11G;
1406 }
1407
1408 break;
1409 case IEEE80211_BAND_5GHZ:
7cc45e98
SM		 1410 /*
1411 * Check VHT first.
1412 */
1413 if (sta->vht_cap.vht_supported) {
1414 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1415 phymode = MODE_11AC_VHT80;
1416 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1417 phymode = MODE_11AC_VHT40;
1418 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1419 phymode = MODE_11AC_VHT20;
1420 } else if (sta->ht_cap.ht_supported) {
5e3dd157
KV		 1421 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1422 phymode = MODE_11NA_HT40;
1423 else
1424 phymode = MODE_11NA_HT20;
1425 } else {
1426 phymode = MODE_11A;
1427 }
1428
1429 break;
1430 default:
1431 break;
1432 }
1433
7aa7a72a 1434 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
38a1d47e 1435 sta->addr, ath10k_wmi_phymode_str(phymode));
60c3daa8 1436
5e3dd157
KV		 1437 arg->peer_phymode = phymode;
1438 WARN_ON(phymode == MODE_UNKNOWN);
1439}
1440
b9ada65d 1441static int ath10k_peer_assoc_prepare(struct ath10k *ar,
590922a8 1442 struct ieee80211_vif *vif,
b9ada65d 1443 struct ieee80211_sta *sta,
b9ada65d 1444 struct wmi_peer_assoc_complete_arg *arg)
5e3dd157 1445{
548db54c
MK		 1446 lockdep_assert_held(&ar->conf_mutex);
1447
b9ada65d 1448 memset(arg, 0, sizeof(*arg));
5e3dd157 1449
590922a8
MK		 1450 ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
1451 ath10k_peer_assoc_h_crypto(ar, vif, arg);
b9ada65d
KV		 1452 ath10k_peer_assoc_h_rates(ar, sta, arg);
1453 ath10k_peer_assoc_h_ht(ar, sta, arg);
1454 ath10k_peer_assoc_h_vht(ar, sta, arg);
590922a8
MK		 1455 ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
1456 ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
5e3dd157 1457
b9ada65d 1458 return 0;
5e3dd157
KV		 1459}
1460
90046f50
MK		 1461static const u32 ath10k_smps_map[] = {
1462 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1463 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1464 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1465 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1466};
1467
1468static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1469 const u8 *addr,
1470 const struct ieee80211_sta_ht_cap *ht_cap)
1471{
1472 int smps;
1473
1474 if (!ht_cap->ht_supported)
1475 return 0;
1476
1477 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1478 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1479
1480 if (smps >= ARRAY_SIZE(ath10k_smps_map))
1481 return -EINVAL;
1482
1483 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1484 WMI_PEER_SMPS_STATE,
1485 ath10k_smps_map[smps]);
1486}
1487
5e3dd157
KV		 1488/* can be called only in mac80211 callbacks due to `key_count` usage */
1489static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1490 struct ieee80211_vif *vif,
1491 struct ieee80211_bss_conf *bss_conf)
1492{
1493 struct ath10k *ar = hw->priv;
1494 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
90046f50 1495 struct ieee80211_sta_ht_cap ht_cap;
b9ada65d 1496 struct wmi_peer_assoc_complete_arg peer_arg;
5e3dd157
KV		 1497 struct ieee80211_sta *ap_sta;
1498 int ret;
1499
548db54c
MK		 1500 lockdep_assert_held(&ar->conf_mutex);
1501
077efc8c
MK		 1502 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
1503 arvif->vdev_id, arvif->bssid, arvif->aid);
1504
5e3dd157
KV		 1505 rcu_read_lock();
1506
1507 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1508 if (!ap_sta) {
7aa7a72a 1509 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
69244e56 1510 bss_conf->bssid, arvif->vdev_id);
5e3dd157
KV		 1511 rcu_read_unlock();
1512 return;
1513 }
1514
90046f50
MK		 1515 /* ap_sta must be accessed only within rcu section which must be left
1516 * before calling ath10k_setup_peer_smps() which might sleep. */
1517 ht_cap = ap_sta->ht_cap;
1518
590922a8 1519 ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
5e3dd157 1520 if (ret) {
7aa7a72a 1521 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
69244e56 1522 bss_conf->bssid, arvif->vdev_id, ret);
5e3dd157
KV		 1523 rcu_read_unlock();
1524 return;
1525 }
1526
1527 rcu_read_unlock();
1528
b9ada65d
KV		 1529 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1530 if (ret) {
7aa7a72a 1531 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
69244e56 1532 bss_conf->bssid, arvif->vdev_id, ret);
b9ada65d
KV		 1533 return;
1534 }
1535
90046f50
MK		 1536 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1537 if (ret) {
7aa7a72a 1538 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
69244e56 1539 arvif->vdev_id, ret);
90046f50
MK		 1540 return;
1541 }
1542
7aa7a72a 1543 ath10k_dbg(ar, ATH10K_DBG_MAC,
60c3daa8
KV		 1544 "mac vdev %d up (associated) bssid %pM aid %d\n",
1545 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1546
077efc8c
MK		 1547 WARN_ON(arvif->is_up);
1548
c930f744 1549 arvif->aid = bss_conf->aid;
b25f32cb 1550 ether_addr_copy(arvif->bssid, bss_conf->bssid);
c930f744
MK		 1551
1552 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1553 if (ret) {
7aa7a72a 1554 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
5e3dd157 1555 arvif->vdev_id, ret);
c930f744
MK		 1556 return;
1557 }
1558
1559 arvif->is_up = true;
5e3dd157
KV		 1560}
1561
5e3dd157
KV		 1562static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1563 struct ieee80211_vif *vif)
1564{
1565 struct ath10k *ar = hw->priv;
1566 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1567 int ret;
1568
548db54c
MK		 1569 lockdep_assert_held(&ar->conf_mutex);
1570
077efc8c
MK		 1571 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
1572 arvif->vdev_id, arvif->bssid);
60c3daa8 1573
5e3dd157 1574 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
077efc8c
MK		 1575 if (ret)
1576 ath10k_warn(ar, "faield to down vdev %i: %d\n",
1577 arvif->vdev_id, ret);
5e3dd157 1578
cc4827b9 1579 arvif->def_wep_key_idx = 0;
c930f744 1580 arvif->is_up = false;
5e3dd157
KV		 1581}
1582
590922a8
MK		 1583static int ath10k_station_assoc(struct ath10k *ar,
1584 struct ieee80211_vif *vif,
1585 struct ieee80211_sta *sta,
1586 bool reassoc)
5e3dd157 1587{
590922a8 1588 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
b9ada65d 1589 struct wmi_peer_assoc_complete_arg peer_arg;
5e3dd157
KV		 1590 int ret = 0;
1591
548db54c
MK		 1592 lockdep_assert_held(&ar->conf_mutex);
1593
590922a8 1594 ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
b9ada65d 1595 if (ret) {
7aa7a72a 1596 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
69244e56 1597 sta->addr, arvif->vdev_id, ret);
b9ada65d
KV		 1598 return ret;
1599 }
1600
44d6fa90 1601 peer_arg.peer_reassoc = reassoc;
b9ada65d 1602 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
5e3dd157 1603 if (ret) {
7aa7a72a 1604 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
69244e56 1605 sta->addr, arvif->vdev_id, ret);
5e3dd157
KV		 1606 return ret;
1607 }
1608
b1ecde36
MK		 1609 /* Re-assoc is run only to update supported rates for given station. It
1610 * doesn't make much sense to reconfigure the peer completely.
1611 */
1612 if (!reassoc) {
1613 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
1614 &sta->ht_cap);
e81bd104 1615 if (ret) {
b1ecde36 1616 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
e81bd104
MK		 1617 arvif->vdev_id, ret);
1618 return ret;
1619 }
e81bd104 1620
b1ecde36
MK		 1621 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1622 if (ret) {
1623 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
1624 sta->addr, arvif->vdev_id, ret);
1625 return ret;
1626 }
5e3dd157 1627
b1ecde36
MK		 1628 if (!sta->wme) {
1629 arvif->num_legacy_stations++;
1630 ret = ath10k_recalc_rtscts_prot(arvif);
1631 if (ret) {
1632 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1633 arvif->vdev_id, ret);
1634 return ret;
1635 }
1636 }
1637
1638 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1639 if (ret) {
1640 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
1641 arvif->vdev_id, ret);
1642 return ret;
1643 }
d3d3ff42
JD		 1644 }
1645
5e3dd157
KV		 1646 return ret;
1647}
1648
590922a8
MK		 1649static int ath10k_station_disassoc(struct ath10k *ar,
1650 struct ieee80211_vif *vif,
5e3dd157
KV		 1651 struct ieee80211_sta *sta)
1652{
590922a8 1653 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5e3dd157
KV		 1654 int ret = 0;
1655
548db54c
MK		 1656 lockdep_assert_held(&ar->conf_mutex);
1657
e81bd104
MK		 1658 if (!sta->wme) {
1659 arvif->num_legacy_stations--;
1660 ret = ath10k_recalc_rtscts_prot(arvif);
1661 if (ret) {
7aa7a72a 1662 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
e81bd104
MK		 1663 arvif->vdev_id, ret);
1664 return ret;
1665 }
1666 }
1667
5e3dd157
KV		 1668 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1669 if (ret) {
7aa7a72a 1670 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
69244e56 1671 arvif->vdev_id, ret);
5e3dd157
KV		 1672 return ret;
1673 }
1674
1675 return ret;
1676}
1677
1678/**************/
1679/* Regulatory */
1680/**************/
1681
1682static int ath10k_update_channel_list(struct ath10k *ar)
1683{
1684 struct ieee80211_hw *hw = ar->hw;
1685 struct ieee80211_supported_band **bands;
1686 enum ieee80211_band band;
1687 struct ieee80211_channel *channel;
1688 struct wmi_scan_chan_list_arg arg = {0};
1689 struct wmi_channel_arg *ch;
1690 bool passive;
1691 int len;
1692 int ret;
1693 int i;
1694
548db54c
MK		 1695 lockdep_assert_held(&ar->conf_mutex);
1696
5e3dd157
KV		 1697 bands = hw->wiphy->bands;
1698 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1699 if (!bands[band])
1700 continue;
1701
1702 for (i = 0; i < bands[band]->n_channels; i++) {
1703 if (bands[band]->channels[i].flags &
1704 IEEE80211_CHAN_DISABLED)
1705 continue;
1706
1707 arg.n_channels++;
1708 }
1709 }
1710
1711 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1712 arg.channels = kzalloc(len, GFP_KERNEL);
1713 if (!arg.channels)
1714 return -ENOMEM;
1715
1716 ch = arg.channels;
1717 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1718 if (!bands[band])
1719 continue;
1720
1721 for (i = 0; i < bands[band]->n_channels; i++) {
1722 channel = &bands[band]->channels[i];
1723
1724 if (channel->flags & IEEE80211_CHAN_DISABLED)
1725 continue;
1726
1727 ch->allow_ht = true;
1728
1729 /* FIXME: when should we really allow VHT? */
1730 ch->allow_vht = true;
1731
1732 ch->allow_ibss =
8fe02e16 1733 !(channel->flags & IEEE80211_CHAN_NO_IR);
5e3dd157
KV		 1734
1735 ch->ht40plus =
1736 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1737
e8a50f8b
MP		 1738 ch->chan_radar =
1739 !!(channel->flags & IEEE80211_CHAN_RADAR);
1740
8fe02e16 1741 passive = channel->flags & IEEE80211_CHAN_NO_IR;
5e3dd157
KV		 1742 ch->passive = passive;
1743
1744 ch->freq = channel->center_freq;
2d66721c 1745 ch->band_center_freq1 = channel->center_freq;
89c5c843 1746 ch->min_power = 0;
02256930
MK		 1747 ch->max_power = channel->max_power * 2;
1748 ch->max_reg_power = channel->max_reg_power * 2;
1749 ch->max_antenna_gain = channel->max_antenna_gain * 2;
5e3dd157
KV		 1750 ch->reg_class_id = 0; /* FIXME */
1751
1752 /* FIXME: why use only legacy modes, why not any
1753 * HT/VHT modes? Would that even make any
1754 * difference? */
1755 if (channel->band == IEEE80211_BAND_2GHZ)
1756 ch->mode = MODE_11G;
1757 else
1758 ch->mode = MODE_11A;
1759
1760 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1761 continue;
1762
7aa7a72a 1763 ath10k_dbg(ar, ATH10K_DBG_WMI,
60c3daa8
KV		 1764 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1765 ch - arg.channels, arg.n_channels,
5e3dd157
KV		 1766 ch->freq, ch->max_power, ch->max_reg_power,
1767 ch->max_antenna_gain, ch->mode);
1768
1769 ch++;
1770 }
1771 }
1772
1773 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1774 kfree(arg.channels);
1775
1776 return ret;
1777}
1778
821af6ae
MP		 1779static enum wmi_dfs_region
1780ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
1781{
1782 switch (dfs_region) {
1783 case NL80211_DFS_UNSET:
1784 return WMI_UNINIT_DFS_DOMAIN;
1785 case NL80211_DFS_FCC:
1786 return WMI_FCC_DFS_DOMAIN;
1787 case NL80211_DFS_ETSI:
1788 return WMI_ETSI_DFS_DOMAIN;
1789 case NL80211_DFS_JP:
1790 return WMI_MKK4_DFS_DOMAIN;
1791 }
1792 return WMI_UNINIT_DFS_DOMAIN;
1793}
1794
f7843d7f 1795static void ath10k_regd_update(struct ath10k *ar)
5e3dd157 1796{
5e3dd157 1797 struct reg_dmn_pair_mapping *regpair;
5e3dd157 1798 int ret;
821af6ae
MP		 1799 enum wmi_dfs_region wmi_dfs_reg;
1800 enum nl80211_dfs_regions nl_dfs_reg;
5e3dd157 1801
f7843d7f 1802 lockdep_assert_held(&ar->conf_mutex);
5e3dd157
KV		 1803
1804 ret = ath10k_update_channel_list(ar);
1805 if (ret)
7aa7a72a 1806 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
5e3dd157
KV		 1807
1808 regpair = ar->ath_common.regulatory.regpair;
f7843d7f 1809
821af6ae
MP		 1810 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1811 nl_dfs_reg = ar->dfs_detector->region;
1812 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
1813 } else {
1814 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
1815 }
1816
5e3dd157
KV		 1817 /* Target allows setting up per-band regdomain but ath_common provides
1818 * a combined one only */
1819 ret = ath10k_wmi_pdev_set_regdomain(ar,
ef8c0017
KV		 1820 regpair->reg_domain,
1821 regpair->reg_domain, /* 2ghz */
1822 regpair->reg_domain, /* 5ghz */
5e3dd157 1823 regpair->reg_2ghz_ctl,
821af6ae
MP		 1824 regpair->reg_5ghz_ctl,
1825 wmi_dfs_reg);
5e3dd157 1826 if (ret)
7aa7a72a 1827 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
f7843d7f 1828}
548db54c 1829
f7843d7f
MK		 1830static void ath10k_reg_notifier(struct wiphy *wiphy,
1831 struct regulatory_request *request)
1832{
1833 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1834 struct ath10k *ar = hw->priv;
9702c686 1835 bool result;
f7843d7f
MK		 1836
1837 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1838
9702c686 1839 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
7aa7a72a 1840 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
9702c686
JD		 1841 request->dfs_region);
1842 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1843 request->dfs_region);
1844 if (!result)
7aa7a72a 1845 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
9702c686
JD		 1846 request->dfs_region);
1847 }
1848
f7843d7f
MK		 1849 mutex_lock(&ar->conf_mutex);
1850 if (ar->state == ATH10K_STATE_ON)
1851 ath10k_regd_update(ar);
548db54c 1852 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 1853}
1854
1855/***************/
1856/* TX handlers */
1857/***************/
1858
42c3aa6f
MK		 1859static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1860{
1861 if (ieee80211_is_mgmt(hdr->frame_control))
1862 return HTT_DATA_TX_EXT_TID_MGMT;
1863
1864 if (!ieee80211_is_data_qos(hdr->frame_control))
1865 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1866
1867 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1868 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1869
1870 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1871}
1872
2b37c295 1873static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif)
ddb6ad77 1874{
2b37c295
MK		 1875 if (vif)
1876 return ath10k_vif_to_arvif(vif)->vdev_id;
ddb6ad77 1877
1bbc0975 1878 if (ar->monitor_started)
ddb6ad77
MK		 1879 return ar->monitor_vdev_id;
1880
7aa7a72a 1881 ath10k_warn(ar, "failed to resolve vdev id\n");
ddb6ad77
MK		 1882 return 0;
1883}
1884
4b604558
MK		 1885/* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
1886 * Control in the header.
5e3dd157 1887 */
4b604558 1888static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
5e3dd157
KV		 1889{
1890 struct ieee80211_hdr *hdr = (void *)skb->data;
c21c64d1 1891 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
5e3dd157
KV		 1892 u8 *qos_ctl;
1893
1894 if (!ieee80211_is_data_qos(hdr->frame_control))
1895 return;
1896
1897 qos_ctl = ieee80211_get_qos_ctl(hdr);
ba0ccd7a
MK		 1898 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1899 skb->data, (void *)qos_ctl - (void *)skb->data);
1900 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
c21c64d1
MK		 1901
1902 /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
1903 * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
1904 * used only for CQM purposes (e.g. hostapd station keepalive ping) so
1905 * it is safe to downgrade to NullFunc.
1906 */
1907 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) {
1908 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1909 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1910 }
5e3dd157
KV		 1911}
1912
cc4827b9
MK		 1913static void ath10k_tx_wep_key_work(struct work_struct *work)
1914{
1915 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1916 wep_key_work);
7aa7a72a 1917 struct ath10k *ar = arvif->ar;
cc4827b9
MK		 1918 int ret, keyidx = arvif->def_wep_key_newidx;
1919
911e6c0d
MK		 1920 mutex_lock(&arvif->ar->conf_mutex);
1921
1922 if (arvif->ar->state != ATH10K_STATE_ON)
1923 goto unlock;
1924
cc4827b9 1925 if (arvif->def_wep_key_idx == keyidx)
911e6c0d 1926 goto unlock;
cc4827b9 1927
7aa7a72a 1928 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
cc4827b9
MK		 1929 arvif->vdev_id, keyidx);
1930
1931 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1932 arvif->vdev_id,
1933 arvif->ar->wmi.vdev_param->def_keyid,
1934 keyidx);
1935 if (ret) {
7aa7a72a 1936 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
be6546fc
KV		 1937 arvif->vdev_id,
1938 ret);
911e6c0d 1939 goto unlock;
cc4827b9
MK		 1940 }
1941
1942 arvif->def_wep_key_idx = keyidx;
911e6c0d
MK		 1943
1944unlock:
1945 mutex_unlock(&arvif->ar->conf_mutex);
cc4827b9
MK		 1946}
1947
4b604558
MK		 1948static void ath10k_tx_h_update_wep_key(struct ieee80211_vif *vif,
1949 struct ieee80211_key_conf *key,
1950 struct sk_buff *skb)
5e3dd157 1951{
5e3dd157
KV		 1952 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1953 struct ath10k *ar = arvif->ar;
1954 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5e3dd157 1955
5e3dd157
KV		 1956 if (!ieee80211_has_protected(hdr->frame_control))
1957 return;
1958
1959 if (!key)
1960 return;
1961
1962 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1963 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1964 return;
1965
cc4827b9 1966 if (key->keyidx == arvif->def_wep_key_idx)
5e3dd157 1967 return;
5e3dd157 1968
cc4827b9
MK		 1969 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1970 * queueing frames until key index is updated is not an option because
1971 * sk_buff may need more processing to be done, e.g. offchannel */
1972 arvif->def_wep_key_newidx = key->keyidx;
1973 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
5e3dd157
KV		 1974}
1975
4b604558
MK		 1976static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
1977 struct ieee80211_vif *vif,
1978 struct sk_buff *skb)
5e3dd157
KV		 1979{
1980 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5e3dd157
KV		 1981 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1982
1983 /* This is case only for P2P_GO */
1984 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1985 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1986 return;
1987
1988 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1989 spin_lock_bh(&ar->data_lock);
1990 if (arvif->u.ap.noa_data)
1991 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1992 GFP_ATOMIC))
1993 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1994 arvif->u.ap.noa_data,
1995 arvif->u.ap.noa_len);
1996 spin_unlock_bh(&ar->data_lock);
1997 }
1998}
1999
8d6d3624
MK		 2000static bool ath10k_mac_need_offchan_tx_work(struct ath10k *ar)
2001{
2002 /* FIXME: Not really sure since when the behaviour changed. At some
2003 * point new firmware stopped requiring creation of peer entries for
2004 * offchannel tx (and actually creating them causes issues with wmi-htc
2005 * tx credit replenishment and reliability). Assuming it's at least 3.4
2006 * because that's when the `freq` was introduced to TX_FRM HTT command.
2007 */
2008 return !(ar->htt.target_version_major >= 3 &&
2009 ar->htt.target_version_minor >= 4);
2010}
2011
5e3dd157
KV		 2012static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
2013{
2014 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5e00d31a 2015 int ret = 0;
5e3dd157 2016
961d4c38
MK		 2017 if (ar->htt.target_version_major >= 3) {
2018 /* Since HTT 3.0 there is no separate mgmt tx command */
2019 ret = ath10k_htt_tx(&ar->htt, skb);
2020 goto exit;
2021 }
2022
5e00d31a
BM		 2023 if (ieee80211_is_mgmt(hdr->frame_control)) {
2024 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2025 ar->fw_features)) {
2026 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
2027 ATH10K_MAX_NUM_MGMT_PENDING) {
7aa7a72a 2028 ath10k_warn(ar, "reached WMI management transmit queue limit\n");
5e00d31a
BM		 2029 ret = -EBUSY;
2030 goto exit;
2031 }
2032
2033 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
2034 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
2035 } else {
2036 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2037 }
2038 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2039 ar->fw_features) &&
2040 ieee80211_is_nullfunc(hdr->frame_control)) {
5e3dd157
KV		 2041 /* FW does not report tx status properly for NullFunc frames
2042 * unless they are sent through mgmt tx path. mac80211 sends
5e00d31a
BM		 2043 * those frames when it detects link/beacon loss and depends
2044 * on the tx status to be correct. */
edb8236d 2045 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
5e00d31a 2046 } else {
edb8236d 2047 ret = ath10k_htt_tx(&ar->htt, skb);
5e00d31a 2048 }
5e3dd157 2049
961d4c38 2050exit:
5e3dd157 2051 if (ret) {
7aa7a72a
MK		 2052 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
2053 ret);
5e3dd157
KV		 2054 ieee80211_free_txskb(ar->hw, skb);
2055 }
2056}
2057
2058void ath10k_offchan_tx_purge(struct ath10k *ar)
2059{
2060 struct sk_buff *skb;
2061
2062 for (;;) {
2063 skb = skb_dequeue(&ar->offchan_tx_queue);
2064 if (!skb)
2065 break;
2066
2067 ieee80211_free_txskb(ar->hw, skb);
2068 }
2069}
2070
2071void ath10k_offchan_tx_work(struct work_struct *work)
2072{
2073 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2074 struct ath10k_peer *peer;
2075 struct ieee80211_hdr *hdr;
2076 struct sk_buff *skb;
2077 const u8 *peer_addr;
2078 int vdev_id;
2079 int ret;
2080
2081 /* FW requirement: We must create a peer before FW will send out
2082 * an offchannel frame. Otherwise the frame will be stuck and
2083 * never transmitted. We delete the peer upon tx completion.
2084 * It is unlikely that a peer for offchannel tx will already be
2085 * present. However it may be in some rare cases so account for that.
2086 * Otherwise we might remove a legitimate peer and break stuff. */
2087
2088 for (;;) {
2089 skb = skb_dequeue(&ar->offchan_tx_queue);
2090 if (!skb)
2091 break;
2092
2093 mutex_lock(&ar->conf_mutex);
2094
7aa7a72a 2095 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
5e3dd157
KV		 2096 skb);
2097
2098 hdr = (struct ieee80211_hdr *)skb->data;
2099 peer_addr = ieee80211_get_DA(hdr);
5e00d31a 2100 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
5e3dd157
KV		 2101
2102 spin_lock_bh(&ar->data_lock);
2103 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2104 spin_unlock_bh(&ar->data_lock);
2105
2106 if (peer)
60c3daa8 2107 /* FIXME: should this use ath10k_warn()? */
7aa7a72a 2108 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
5e3dd157
KV		 2109 peer_addr, vdev_id);
2110
2111 if (!peer) {
2112 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2113 if (ret)
7aa7a72a 2114 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
5e3dd157
KV		 2115 peer_addr, vdev_id, ret);
2116 }
2117
2118 spin_lock_bh(&ar->data_lock);
16735d02 2119 reinit_completion(&ar->offchan_tx_completed);
5e3dd157
KV		 2120 ar->offchan_tx_skb = skb;
2121 spin_unlock_bh(&ar->data_lock);
2122
2123 ath10k_tx_htt(ar, skb);
2124
2125 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2126 3 * HZ);
2127 if (ret <= 0)
7aa7a72a 2128 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
5e3dd157
KV		 2129 skb);
2130
2131 if (!peer) {
2132 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2133 if (ret)
7aa7a72a 2134 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
5e3dd157
KV		 2135 peer_addr, vdev_id, ret);
2136 }
2137
2138 mutex_unlock(&ar->conf_mutex);
2139 }
2140}
2141
5e00d31a
BM		 2142void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2143{
2144 struct sk_buff *skb;
2145
2146 for (;;) {
2147 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2148 if (!skb)
2149 break;
2150
2151 ieee80211_free_txskb(ar->hw, skb);
2152 }
2153}
2154
2155void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2156{
2157 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2158 struct sk_buff *skb;
2159 int ret;
2160
2161 for (;;) {
2162 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2163 if (!skb)
2164 break;
2165
2166 ret = ath10k_wmi_mgmt_tx(ar, skb);
5fb5e41f 2167 if (ret) {
7aa7a72a 2168 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
be6546fc 2169 ret);
5fb5e41f
MK		 2170 ieee80211_free_txskb(ar->hw, skb);
2171 }
5e00d31a
BM		 2172 }
2173}
2174
5e3dd157
KV		 2175/************/
2176/* Scanning */
2177/************/
2178
5c81c7fd 2179void __ath10k_scan_finish(struct ath10k *ar)
5e3dd157 2180{
5c81c7fd 2181 lockdep_assert_held(&ar->data_lock);
5e3dd157 2182
5c81c7fd
MK		 2183 switch (ar->scan.state) {
2184 case ATH10K_SCAN_IDLE:
2185 break;
2186 case ATH10K_SCAN_RUNNING:
2187 case ATH10K_SCAN_ABORTING:
2188 if (ar->scan.is_roc)
2189 ieee80211_remain_on_channel_expired(ar->hw);
2190 else
2191 ieee80211_scan_completed(ar->hw,
2192 (ar->scan.state ==
2193 ATH10K_SCAN_ABORTING));
2194 /* fall through */
2195 case ATH10K_SCAN_STARTING:
2196 ar->scan.state = ATH10K_SCAN_IDLE;
2197 ar->scan_channel = NULL;
2198 ath10k_offchan_tx_purge(ar);
2199 cancel_delayed_work(&ar->scan.timeout);
2200 complete_all(&ar->scan.completed);
2201 break;
5e3dd157 2202 }
5c81c7fd 2203}
5e3dd157 2204
5c81c7fd
MK		 2205void ath10k_scan_finish(struct ath10k *ar)
2206{
2207 spin_lock_bh(&ar->data_lock);
2208 __ath10k_scan_finish(ar);
5e3dd157
KV		 2209 spin_unlock_bh(&ar->data_lock);
2210}
2211
5c81c7fd 2212static int ath10k_scan_stop(struct ath10k *ar)
5e3dd157
KV		 2213{
2214 struct wmi_stop_scan_arg arg = {
2215 .req_id = 1, /* FIXME */
2216 .req_type = WMI_SCAN_STOP_ONE,
2217 .u.scan_id = ATH10K_SCAN_ID,
2218 };
2219 int ret;
2220
2221 lockdep_assert_held(&ar->conf_mutex);
2222
5e3dd157
KV		 2223 ret = ath10k_wmi_stop_scan(ar, &arg);
2224 if (ret) {
7aa7a72a 2225 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
5c81c7fd 2226 goto out;
5e3dd157
KV		 2227 }
2228
5e3dd157 2229 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
5c81c7fd 2230 if (ret == 0) {
7aa7a72a 2231 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
5c81c7fd
MK		 2232 ret = -ETIMEDOUT;
2233 } else if (ret > 0) {
2234 ret = 0;
2235 }
5e3dd157 2236
5c81c7fd
MK		 2237out:
2238 /* Scan state should be updated upon scan completion but in case
2239 * firmware fails to deliver the event (for whatever reason) it is
2240 * desired to clean up scan state anyway. Firmware may have just
2241 * dropped the scan completion event delivery due to transport pipe
2242 * being overflown with data and/or it can recover on its own before
2243 * next scan request is submitted.
2244 */
2245 spin_lock_bh(&ar->data_lock);
2246 if (ar->scan.state != ATH10K_SCAN_IDLE)
2247 __ath10k_scan_finish(ar);
2248 spin_unlock_bh(&ar->data_lock);
2249
2250 return ret;
2251}
2252
2253static void ath10k_scan_abort(struct ath10k *ar)
2254{
2255 int ret;
2256
2257 lockdep_assert_held(&ar->conf_mutex);
5e3dd157
KV		 2258
2259 spin_lock_bh(&ar->data_lock);
5c81c7fd
MK		 2260
2261 switch (ar->scan.state) {
2262 case ATH10K_SCAN_IDLE:
2263 /* This can happen if timeout worker kicked in and called
2264 * abortion while scan completion was being processed.
2265 */
2266 break;
2267 case ATH10K_SCAN_STARTING:
2268 case ATH10K_SCAN_ABORTING:
7aa7a72a 2269 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
5c81c7fd
MK		 2270 ath10k_scan_state_str(ar->scan.state),
2271 ar->scan.state);
2272 break;
2273 case ATH10K_SCAN_RUNNING:
2274 ar->scan.state = ATH10K_SCAN_ABORTING;
2275 spin_unlock_bh(&ar->data_lock);
2276
2277 ret = ath10k_scan_stop(ar);
2278 if (ret)
7aa7a72a 2279 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
5c81c7fd
MK		 2280
2281 spin_lock_bh(&ar->data_lock);
2282 break;
5e3dd157 2283 }
5c81c7fd 2284
5e3dd157 2285 spin_unlock_bh(&ar->data_lock);
5c81c7fd 2286}
5e3dd157 2287
5c81c7fd
MK		 2288void ath10k_scan_timeout_work(struct work_struct *work)
2289{
2290 struct ath10k *ar = container_of(work, struct ath10k,
2291 scan.timeout.work);
2292
2293 mutex_lock(&ar->conf_mutex);
2294 ath10k_scan_abort(ar);
2295 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 2296}
2297
2298static int ath10k_start_scan(struct ath10k *ar,
2299 const struct wmi_start_scan_arg *arg)
2300{
2301 int ret;
2302
2303 lockdep_assert_held(&ar->conf_mutex);
2304
2305 ret = ath10k_wmi_start_scan(ar, arg);
2306 if (ret)
2307 return ret;
2308
5e3dd157
KV		 2309 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2310 if (ret == 0) {
5c81c7fd
MK		 2311 ret = ath10k_scan_stop(ar);
2312 if (ret)
7aa7a72a 2313 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5c81c7fd
MK		 2314
2315 return -ETIMEDOUT;
5e3dd157
KV		 2316 }
2317
5c81c7fd
MK		 2318 /* Add a 200ms margin to account for event/command processing */
2319 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
2320 msecs_to_jiffies(arg->max_scan_time+200));
5e3dd157
KV		 2321 return 0;
2322}
2323
2324/**********************/
2325/* mac80211 callbacks */
2326/**********************/
2327
2328static void ath10k_tx(struct ieee80211_hw *hw,
2329 struct ieee80211_tx_control *control,
2330 struct sk_buff *skb)
2331{
4b604558 2332 struct ath10k *ar = hw->priv;
5e3dd157 2333 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
4b604558
MK		 2334 struct ieee80211_vif *vif = info->control.vif;
2335 struct ieee80211_key_conf *key = info->control.hw_key;
5e3dd157 2336 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
5e3dd157
KV		 2337
2338 /* We should disable CCK RATE due to P2P */
2339 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
7aa7a72a 2340 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
5e3dd157 2341
4b604558
MK		 2342 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2343 ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
2b37c295 2344 ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
5e3dd157 2345
cf84bd4d 2346 /* it makes no sense to process injected frames like that */
4b604558
MK		 2347 if (vif && vif->type != NL80211_IFTYPE_MONITOR) {
2348 ath10k_tx_h_nwifi(hw, skb);
2349 ath10k_tx_h_update_wep_key(vif, key, skb);
2350 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
2351 ath10k_tx_h_seq_no(vif, skb);
cf84bd4d 2352 }
5e3dd157 2353
5e3dd157
KV		 2354 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2355 spin_lock_bh(&ar->data_lock);
8d6d3624 2356 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq;
5e00d31a 2357 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
5e3dd157
KV		 2358 spin_unlock_bh(&ar->data_lock);
2359
8d6d3624
MK		 2360 if (ath10k_mac_need_offchan_tx_work(ar)) {
2361 ATH10K_SKB_CB(skb)->htt.freq = 0;
2362 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
5e3dd157 2363
8d6d3624
MK		 2364 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
2365 skb);
2366
2367 skb_queue_tail(&ar->offchan_tx_queue, skb);
2368 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2369 return;
2370 }
5e3dd157
KV		 2371 }
2372
2373 ath10k_tx_htt(ar, skb);
2374}
2375
bca7bafb 2376/* Must not be called with conf_mutex held as workers can use that also. */
7962b0d8 2377void ath10k_drain_tx(struct ath10k *ar)
bca7bafb
MK		 2378{
2379 /* make sure rcu-protected mac80211 tx path itself is drained */
2380 synchronize_net();
2381
2382 ath10k_offchan_tx_purge(ar);
2383 ath10k_mgmt_over_wmi_tx_purge(ar);
2384
2385 cancel_work_sync(&ar->offchan_tx_work);
2386 cancel_work_sync(&ar->wmi_mgmt_tx_work);
2387}
2388
affd3217 2389void ath10k_halt(struct ath10k *ar)
818bdd16 2390{
d9bc4b9b
MK		 2391 struct ath10k_vif *arvif;
2392
818bdd16
MK		 2393 lockdep_assert_held(&ar->conf_mutex);
2394
1933747f
MK		 2395 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2396 ar->filter_flags = 0;
2397 ar->monitor = false;
2398
2399 if (ar->monitor_started)
1bbc0975 2400 ath10k_monitor_stop(ar);
1933747f
MK		 2401
2402 ar->monitor_started = false;
1bbc0975 2403
5c81c7fd 2404 ath10k_scan_finish(ar);
818bdd16
MK		 2405 ath10k_peer_cleanup_all(ar);
2406 ath10k_core_stop(ar);
2407 ath10k_hif_power_down(ar);
2408
2409 spin_lock_bh(&ar->data_lock);
64badcb6
MK		 2410 list_for_each_entry(arvif, &ar->arvifs, list)
2411 ath10k_mac_vif_beacon_cleanup(arvif);
818bdd16
MK		 2412 spin_unlock_bh(&ar->data_lock);
2413}
2414
46acf7bb
BG		 2415static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2416{
2417 struct ath10k *ar = hw->priv;
2418
2419 mutex_lock(&ar->conf_mutex);
2420
2421 if (ar->cfg_tx_chainmask) {
2422 *tx_ant = ar->cfg_tx_chainmask;
2423 *rx_ant = ar->cfg_rx_chainmask;
2424 } else {
2425 *tx_ant = ar->supp_tx_chainmask;
2426 *rx_ant = ar->supp_rx_chainmask;
2427 }
2428
2429 mutex_unlock(&ar->conf_mutex);
2430
2431 return 0;
2432}
2433
5572a95b
BG		 2434static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
2435{
2436 /* It is not clear that allowing gaps in chainmask
2437 * is helpful. Probably it will not do what user
2438 * is hoping for, so warn in that case.
2439 */
2440 if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
2441 return;
2442
2443 ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
2444 dbg, cm);
2445}
2446
46acf7bb
BG		 2447static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2448{
2449 int ret;
2450
2451 lockdep_assert_held(&ar->conf_mutex);
2452
5572a95b
BG		 2453 ath10k_check_chain_mask(ar, tx_ant, "tx");
2454 ath10k_check_chain_mask(ar, rx_ant, "rx");
2455
46acf7bb
BG		 2456 ar->cfg_tx_chainmask = tx_ant;
2457 ar->cfg_rx_chainmask = rx_ant;
2458
2459 if ((ar->state != ATH10K_STATE_ON) &&
2460 (ar->state != ATH10K_STATE_RESTARTED))
2461 return 0;
2462
2463 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2464 tx_ant);
2465 if (ret) {
7aa7a72a 2466 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
46acf7bb
BG		 2467 ret, tx_ant);
2468 return ret;
2469 }
2470
2471 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2472 rx_ant);
2473 if (ret) {
7aa7a72a 2474 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
46acf7bb
BG		 2475 ret, rx_ant);
2476 return ret;
2477 }
2478
2479 return 0;
2480}
2481
2482static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2483{
2484 struct ath10k *ar = hw->priv;
2485 int ret;
2486
2487 mutex_lock(&ar->conf_mutex);
2488 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2489 mutex_unlock(&ar->conf_mutex);
2490 return ret;
2491}
2492
5e3dd157
KV		 2493static int ath10k_start(struct ieee80211_hw *hw)
2494{
2495 struct ath10k *ar = hw->priv;
818bdd16 2496 int ret = 0;
5e3dd157 2497
bca7bafb
MK		 2498 /*
2499 * This makes sense only when restarting hw. It is harmless to call
2500 * uncoditionally. This is necessary to make sure no HTT/WMI tx
2501 * commands will be submitted while restarting.
2502 */
2503 ath10k_drain_tx(ar);
2504
548db54c
MK		 2505 mutex_lock(&ar->conf_mutex);
2506
c5058f5b
MK		 2507 switch (ar->state) {
2508 case ATH10K_STATE_OFF:
2509 ar->state = ATH10K_STATE_ON;
2510 break;
2511 case ATH10K_STATE_RESTARTING:
2512 ath10k_halt(ar);
2513 ar->state = ATH10K_STATE_RESTARTED;
2514 break;
2515 case ATH10K_STATE_ON:
2516 case ATH10K_STATE_RESTARTED:
2517 case ATH10K_STATE_WEDGED:
2518 WARN_ON(1);
818bdd16 2519 ret = -EINVAL;
ae254433 2520 goto err;
43d2a30f
KV		 2521 case ATH10K_STATE_UTF:
2522 ret = -EBUSY;
2523 goto err;
818bdd16
MK		 2524 }
2525
2526 ret = ath10k_hif_power_up(ar);
2527 if (ret) {
7aa7a72a 2528 ath10k_err(ar, "Could not init hif: %d\n", ret);
ae254433 2529 goto err_off;
818bdd16
MK		 2530 }
2531
43d2a30f 2532 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
818bdd16 2533 if (ret) {
7aa7a72a 2534 ath10k_err(ar, "Could not init core: %d\n", ret);
ae254433 2535 goto err_power_down;
818bdd16
MK		 2536 }
2537
226a339b 2538 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
ae254433 2539 if (ret) {
7aa7a72a 2540 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
ae254433
MK		 2541 goto err_core_stop;
2542 }
5e3dd157 2543
c4dd0d01 2544 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
ae254433 2545 if (ret) {
7aa7a72a 2546 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
ae254433
MK		 2547 goto err_core_stop;
2548 }
5e3dd157 2549
46acf7bb
BG		 2550 if (ar->cfg_tx_chainmask)
2551 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2552 ar->cfg_rx_chainmask);
2553
ab6258ed
MP		 2554 /*
2555 * By default FW set ARP frames ac to voice (6). In that case ARP
2556 * exchange is not working properly for UAPSD enabled AP. ARP requests
2557 * which arrives with access category 0 are processed by network stack
2558 * and send back with access category 0, but FW changes access category
2559 * to 6. Set ARP frames access category to best effort (0) solves
2560 * this problem.
2561 */
2562
2563 ret = ath10k_wmi_pdev_set_param(ar,
2564 ar->wmi.pdev_param->arp_ac_override, 0);
2565 if (ret) {
7aa7a72a 2566 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
ab6258ed 2567 ret);
ae254433 2568 goto err_core_stop;
ab6258ed
MP		 2569 }
2570
d650097b 2571 ar->num_started_vdevs = 0;
f7843d7f
MK		 2572 ath10k_regd_update(ar);
2573
855aed12
SW		 2574 ath10k_spectral_start(ar);
2575
ae254433
MK		 2576 mutex_unlock(&ar->conf_mutex);
2577 return 0;
2578
2579err_core_stop:
2580 ath10k_core_stop(ar);
2581
2582err_power_down:
2583 ath10k_hif_power_down(ar);
2584
2585err_off:
2586 ar->state = ATH10K_STATE_OFF;
2587
2588err:
548db54c 2589 mutex_unlock(&ar->conf_mutex);
c60bdd83 2590 return ret;
5e3dd157
KV		 2591}
2592
2593static void ath10k_stop(struct ieee80211_hw *hw)
2594{
2595 struct ath10k *ar = hw->priv;
2596
bca7bafb
MK		 2597 ath10k_drain_tx(ar);
2598
548db54c 2599 mutex_lock(&ar->conf_mutex);
c5058f5b 2600 if (ar->state != ATH10K_STATE_OFF) {
818bdd16 2601 ath10k_halt(ar);
c5058f5b
MK		 2602 ar->state = ATH10K_STATE_OFF;
2603 }
548db54c
MK		 2604 mutex_unlock(&ar->conf_mutex);
2605
5c81c7fd 2606 cancel_delayed_work_sync(&ar->scan.timeout);
affd3217 2607 cancel_work_sync(&ar->restart_work);
5e3dd157
KV		 2608}
2609
ad088bfa 2610static int ath10k_config_ps(struct ath10k *ar)
5e3dd157 2611{
ad088bfa
MK		 2612 struct ath10k_vif *arvif;
2613 int ret = 0;
affd3217
MK		 2614
2615 lockdep_assert_held(&ar->conf_mutex);
2616
ad088bfa
MK		 2617 list_for_each_entry(arvif, &ar->arvifs, list) {
2618 ret = ath10k_mac_vif_setup_ps(arvif);
2619 if (ret) {
7aa7a72a 2620 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
ad088bfa
MK		 2621 break;
2622 }
2623 }
affd3217 2624
ad088bfa 2625 return ret;
affd3217
MK		 2626}
2627
c930f744
MK		 2628static const char *chandef_get_width(enum nl80211_chan_width width)
2629{
2630 switch (width) {
2631 case NL80211_CHAN_WIDTH_20_NOHT:
2632 return "20 (noht)";
2633 case NL80211_CHAN_WIDTH_20:
2634 return "20";
2635 case NL80211_CHAN_WIDTH_40:
2636 return "40";
2637 case NL80211_CHAN_WIDTH_80:
2638 return "80";
2639 case NL80211_CHAN_WIDTH_80P80:
2640 return "80+80";
2641 case NL80211_CHAN_WIDTH_160:
2642 return "160";
2643 case NL80211_CHAN_WIDTH_5:
2644 return "5";
2645 case NL80211_CHAN_WIDTH_10:
2646 return "10";
2647 }
2648 return "?";
2649}
2650
2651static void ath10k_config_chan(struct ath10k *ar)
2652{
2653 struct ath10k_vif *arvif;
c930f744
MK		 2654 int ret;
2655
2656 lockdep_assert_held(&ar->conf_mutex);
2657
7aa7a72a 2658 ath10k_dbg(ar, ATH10K_DBG_MAC,
c930f744
MK		 2659 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2660 ar->chandef.chan->center_freq,
2661 ar->chandef.center_freq1,
2662 ar->chandef.center_freq2,
2663 chandef_get_width(ar->chandef.width));
2664
2665 /* First stop monitor interface. Some FW versions crash if there's a
2666 * lone monitor interface. */
1bbc0975 2667 if (ar->monitor_started)
1933747f 2668 ath10k_monitor_stop(ar);
c930f744
MK		 2669
2670 list_for_each_entry(arvif, &ar->arvifs, list) {
2671 if (!arvif->is_started)
2672 continue;
2673
dc55e307
MK		 2674 if (!arvif->is_up)
2675 continue;
2676
c930f744
MK		 2677 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2678 continue;
2679
dc55e307 2680 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
c930f744 2681 if (ret) {
7aa7a72a 2682 ath10k_warn(ar, "failed to down vdev %d: %d\n",
c930f744
MK		 2683 arvif->vdev_id, ret);
2684 continue;
2685 }
2686 }
2687
dc55e307 2688 /* all vdevs are downed now - attempt to restart and re-up them */
c930f744
MK		 2689
2690 list_for_each_entry(arvif, &ar->arvifs, list) {
2691 if (!arvif->is_started)
2692 continue;
2693
2694 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2695 continue;
2696
dc55e307 2697 ret = ath10k_vdev_restart(arvif);
c930f744 2698 if (ret) {
7aa7a72a 2699 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
c930f744
MK		 2700 arvif->vdev_id, ret);
2701 continue;
2702 }
2703
2704 if (!arvif->is_up)
2705 continue;
2706
2707 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2708 arvif->bssid);
2709 if (ret) {
7aa7a72a 2710 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
c930f744
MK		 2711 arvif->vdev_id, ret);
2712 continue;
2713 }
2714 }
2715
1933747f 2716 ath10k_monitor_recalc(ar);
c930f744
MK		 2717}
2718
7d9d5587
MK		 2719static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
2720{
2721 int ret;
2722 u32 param;
2723
2724 lockdep_assert_held(&ar->conf_mutex);
2725
2726 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
2727
2728 param = ar->wmi.pdev_param->txpower_limit2g;
2729 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2730 if (ret) {
2731 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
2732 txpower, ret);
2733 return ret;
2734 }
2735
2736 param = ar->wmi.pdev_param->txpower_limit5g;
2737 ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
2738 if (ret) {
2739 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
2740 txpower, ret);
2741 return ret;
2742 }
2743
2744 return 0;
2745}
2746
2747static int ath10k_mac_txpower_recalc(struct ath10k *ar)
2748{
2749 struct ath10k_vif *arvif;
2750 int ret, txpower = -1;
2751
2752 lockdep_assert_held(&ar->conf_mutex);
2753
2754 list_for_each_entry(arvif, &ar->arvifs, list) {
2755 WARN_ON(arvif->txpower < 0);
2756
2757 if (txpower == -1)
2758 txpower = arvif->txpower;
2759 else
2760 txpower = min(txpower, arvif->txpower);
2761 }
2762
2763 if (WARN_ON(txpower == -1))
2764 return -EINVAL;
2765
2766 ret = ath10k_mac_txpower_setup(ar, txpower);
2767 if (ret) {
2768 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
2769 txpower, ret);
2770 return ret;
2771 }
2772
2773 return 0;
2774}
2775
affd3217
MK		 2776static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2777{
5e3dd157
KV		 2778 struct ath10k *ar = hw->priv;
2779 struct ieee80211_conf *conf = &hw->conf;
2780 int ret = 0;
5e3dd157
KV		 2781
2782 mutex_lock(&ar->conf_mutex);
2783
2784 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
7aa7a72a 2785 ath10k_dbg(ar, ATH10K_DBG_MAC,
d650097b 2786 "mac config channel %dMHz flags 0x%x radar %d\n",
e8a50f8b 2787 conf->chandef.chan->center_freq,
d650097b
MK		 2788 conf->chandef.chan->flags,
2789 conf->radar_enabled);
e8a50f8b 2790
5e3dd157
KV		 2791 spin_lock_bh(&ar->data_lock);
2792 ar->rx_channel = conf->chandef.chan;
2793 spin_unlock_bh(&ar->data_lock);
e8a50f8b 2794
d650097b
MK		 2795 ar->radar_enabled = conf->radar_enabled;
2796 ath10k_recalc_radar_detection(ar);
c930f744
MK		 2797
2798 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2799 ar->chandef = conf->chandef;
2800 ath10k_config_chan(ar);
2801 }
5e3dd157
KV		 2802 }
2803
affd3217
MK		 2804 if (changed & IEEE80211_CONF_CHANGE_PS)
2805 ath10k_config_ps(ar);
5e3dd157
KV		 2806
2807 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1933747f
MK		 2808 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
2809 ret = ath10k_monitor_recalc(ar);
2810 if (ret)
2811 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5e3dd157
KV		 2812 }
2813
2814 mutex_unlock(&ar->conf_mutex);
2815 return ret;
2816}
2817
5572a95b
BG		 2818static u32 get_nss_from_chainmask(u16 chain_mask)
2819{
2820 if ((chain_mask & 0x15) == 0x15)
2821 return 4;
2822 else if ((chain_mask & 0x7) == 0x7)
2823 return 3;
2824 else if ((chain_mask & 0x3) == 0x3)
2825 return 2;
2826 return 1;
2827}
2828
5e3dd157
KV		 2829/*
2830 * TODO:
2831 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2832 * because we will send mgmt frames without CCK. This requirement
2833 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2834 * in the TX packet.
2835 */
2836static int ath10k_add_interface(struct ieee80211_hw *hw,
2837 struct ieee80211_vif *vif)
2838{
2839 struct ath10k *ar = hw->priv;
2840 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2841 enum wmi_sta_powersave_param param;
2842 int ret = 0;
5a13e76e 2843 u32 value;
5e3dd157 2844 int bit;
6d1506e7 2845 u32 vdev_param;
5e3dd157
KV		 2846
2847 mutex_lock(&ar->conf_mutex);
2848
0dbd09e6
MK		 2849 memset(arvif, 0, sizeof(*arvif));
2850
5e3dd157
KV		 2851 arvif->ar = ar;
2852 arvif->vif = vif;
2853
cc4827b9 2854 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
e63b33f3 2855 INIT_LIST_HEAD(&arvif->list);
cc4827b9 2856
a9aefb3b 2857 if (ar->free_vdev_map == 0) {
7aa7a72a 2858 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
5e3dd157 2859 ret = -EBUSY;
9dad14ae 2860 goto err;
5e3dd157 2861 }
16c11176 2862 bit = __ffs64(ar->free_vdev_map);
5e3dd157 2863
16c11176
BG		 2864 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
2865 bit, ar->free_vdev_map);
5e3dd157 2866
16c11176 2867 arvif->vdev_id = bit;
5e3dd157 2868 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
5e3dd157
KV		 2869
2870 if (ar->p2p)
2871 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2872
2873 switch (vif->type) {
2874 case NL80211_IFTYPE_UNSPECIFIED:
2875 case NL80211_IFTYPE_STATION:
2876 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2877 if (vif->p2p)
2878 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2879 break;
2880 case NL80211_IFTYPE_ADHOC:
2881 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2882 break;
2883 case NL80211_IFTYPE_AP:
2884 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2885
2886 if (vif->p2p)
2887 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2888 break;
2889 case NL80211_IFTYPE_MONITOR:
2890 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2891 break;
2892 default:
2893 WARN_ON(1);
2894 break;
2895 }
2896
64badcb6
MK		 2897 /* Some firmware revisions don't wait for beacon tx completion before
2898 * sending another SWBA event. This could lead to hardware using old
2899 * (freed) beacon data in some cases, e.g. tx credit starvation
2900 * combined with missed TBTT. This is very very rare.
2901 *
2902 * On non-IOMMU-enabled hosts this could be a possible security issue
2903 * because hw could beacon some random data on the air. On
2904 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
2905 * device would crash.
2906 *
2907 * Since there are no beacon tx completions (implicit nor explicit)
2908 * propagated to host the only workaround for this is to allocate a
2909 * DMA-coherent buffer for a lifetime of a vif and use it for all
2910 * beacon tx commands. Worst case for this approach is some beacons may
2911 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
2912 */
2913 if (vif->type == NL80211_IFTYPE_ADHOC ||
2914 vif->type == NL80211_IFTYPE_AP) {
2915 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
2916 IEEE80211_MAX_FRAME_LEN,
2917 &arvif->beacon_paddr,
82d7aba7 2918 GFP_ATOMIC);
64badcb6
MK		 2919 if (!arvif->beacon_buf) {
2920 ret = -ENOMEM;
2921 ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
2922 ret);
2923 goto err;
2924 }
2925 }
2926
2927 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
2928 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
2929 arvif->beacon_buf ? "single-buf" : "per-skb");
5e3dd157
KV		 2930
2931 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2932 arvif->vdev_subtype, vif->addr);
2933 if (ret) {
7aa7a72a 2934 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
69244e56 2935 arvif->vdev_id, ret);
9dad14ae 2936 goto err;
5e3dd157
KV		 2937 }
2938
16c11176 2939 ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
0579119f 2940 list_add(&arvif->list, &ar->arvifs);
9dad14ae 2941
6d1506e7
BM		 2942 vdev_param = ar->wmi.vdev_param->def_keyid;
2943 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
cc4827b9 2944 arvif->def_wep_key_idx);
9dad14ae 2945 if (ret) {
7aa7a72a 2946 ath10k_warn(ar, "failed to set vdev %i default key id: %d\n",
69244e56 2947 arvif->vdev_id, ret);
9dad14ae
MK		 2948 goto err_vdev_delete;
2949 }
5e3dd157 2950
6d1506e7
BM		 2951 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2952 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157 2953 ATH10K_HW_TXRX_NATIVE_WIFI);
ebc9abdd 2954 /* 10.X firmware does not support this VDEV parameter. Do not warn */
9dad14ae 2955 if (ret && ret != -EOPNOTSUPP) {
7aa7a72a 2956 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
69244e56 2957 arvif->vdev_id, ret);
9dad14ae
MK		 2958 goto err_vdev_delete;
2959 }
5e3dd157 2960
5572a95b
BG		 2961 if (ar->cfg_tx_chainmask) {
2962 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
2963
2964 vdev_param = ar->wmi.vdev_param->nss;
2965 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2966 nss);
2967 if (ret) {
2968 ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
2969 arvif->vdev_id, ar->cfg_tx_chainmask, nss,
2970 ret);
2971 goto err_vdev_delete;
2972 }
2973 }
2974
5e3dd157
KV		 2975 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2976 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2977 if (ret) {
7aa7a72a 2978 ath10k_warn(ar, "failed to create vdev %i peer for AP: %d\n",
69244e56 2979 arvif->vdev_id, ret);
9dad14ae 2980 goto err_vdev_delete;
5e3dd157 2981 }
cdf07409 2982
5a13e76e
KV		 2983 ret = ath10k_mac_set_kickout(arvif);
2984 if (ret) {
7aa7a72a 2985 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
69244e56 2986 arvif->vdev_id, ret);
5a13e76e
KV		 2987 goto err_peer_delete;
2988 }
5e3dd157
KV		 2989 }
2990
2991 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2992 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2993 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2994 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2995 param, value);
9dad14ae 2996 if (ret) {
7aa7a72a 2997 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
69244e56 2998 arvif->vdev_id, ret);
9dad14ae
MK		 2999 goto err_peer_delete;
3000 }
5e3dd157
KV		 3001
3002 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
3003 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
3004 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3005 param, value);
9dad14ae 3006 if (ret) {
7aa7a72a 3007 ath10k_warn(ar, "failed to set vdev %i TX wake thresh: %d\n",
69244e56 3008 arvif->vdev_id, ret);
9dad14ae
MK		 3009 goto err_peer_delete;
3010 }
5e3dd157
KV		 3011
3012 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
3013 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
3014 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3015 param, value);
9dad14ae 3016 if (ret) {
7aa7a72a 3017 ath10k_warn(ar, "failed to set vdev %i PSPOLL count: %d\n",
69244e56 3018 arvif->vdev_id, ret);
9dad14ae
MK		 3019 goto err_peer_delete;
3020 }
5e3dd157
KV		 3021 }
3022
424121c3 3023 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
9dad14ae 3024 if (ret) {
7aa7a72a 3025 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
679c54a6 3026 arvif->vdev_id, ret);
9dad14ae
MK		 3027 goto err_peer_delete;
3028 }
679c54a6 3029
424121c3 3030 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
9dad14ae 3031 if (ret) {
7aa7a72a 3032 ath10k_warn(ar, "failed to set frag threshold for vdev %d: %d\n",
679c54a6 3033 arvif->vdev_id, ret);
9dad14ae
MK		 3034 goto err_peer_delete;
3035 }
679c54a6 3036
7d9d5587
MK		 3037 arvif->txpower = vif->bss_conf.txpower;
3038 ret = ath10k_mac_txpower_recalc(ar);
3039 if (ret) {
3040 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3041 goto err_peer_delete;
3042 }
3043
5e3dd157 3044 mutex_unlock(&ar->conf_mutex);
9dad14ae
MK		 3045 return 0;
3046
3047err_peer_delete:
3048 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
3049 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
3050
3051err_vdev_delete:
3052 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
16c11176 3053 ar->free_vdev_map |= 1LL << arvif->vdev_id;
0579119f 3054 list_del(&arvif->list);
9dad14ae
MK		 3055
3056err:
64badcb6
MK		 3057 if (arvif->beacon_buf) {
3058 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
3059 arvif->beacon_buf, arvif->beacon_paddr);
3060 arvif->beacon_buf = NULL;
3061 }
3062
9dad14ae
MK		 3063 mutex_unlock(&ar->conf_mutex);
3064
5e3dd157
KV		 3065 return ret;
3066}
3067
3068static void ath10k_remove_interface(struct ieee80211_hw *hw,
3069 struct ieee80211_vif *vif)
3070{
3071 struct ath10k *ar = hw->priv;
3072 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3073 int ret;
3074
3075 mutex_lock(&ar->conf_mutex);
3076
cc4827b9
MK		 3077 cancel_work_sync(&arvif->wep_key_work);
3078
ed54388a 3079 spin_lock_bh(&ar->data_lock);
64badcb6 3080 ath10k_mac_vif_beacon_cleanup(arvif);
ed54388a
MK		 3081 spin_unlock_bh(&ar->data_lock);
3082
855aed12
SW		 3083 ret = ath10k_spectral_vif_stop(arvif);
3084 if (ret)
7aa7a72a 3085 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
855aed12
SW		 3086 arvif->vdev_id, ret);
3087
16c11176 3088 ar->free_vdev_map |= 1LL << arvif->vdev_id;
0579119f 3089 list_del(&arvif->list);
5e3dd157
KV		 3090
3091 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
3092 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
3093 if (ret)
7aa7a72a 3094 ath10k_warn(ar, "failed to remove peer for AP vdev %i: %d\n",
69244e56 3095 arvif->vdev_id, ret);
5e3dd157
KV		 3096
3097 kfree(arvif->u.ap.noa_data);
3098 }
3099
7aa7a72a 3100 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
60c3daa8
KV		 3101 arvif->vdev_id);
3102
5e3dd157
KV		 3103 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
3104 if (ret)
7aa7a72a 3105 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
69244e56 3106 arvif->vdev_id, ret);
5e3dd157 3107
5e3dd157
KV		 3108 ath10k_peer_cleanup(ar, arvif->vdev_id);
3109
3110 mutex_unlock(&ar->conf_mutex);
3111}
3112
3113/*
3114 * FIXME: Has to be verified.
3115 */
3116#define SUPPORTED_FILTERS \
3117 (FIF_PROMISC_IN_BSS | \
3118 FIF_ALLMULTI | \
3119 FIF_CONTROL | \
3120 FIF_PSPOLL | \
3121 FIF_OTHER_BSS | \
3122 FIF_BCN_PRBRESP_PROMISC | \
3123 FIF_PROBE_REQ | \
3124 FIF_FCSFAIL)
3125
3126static void ath10k_configure_filter(struct ieee80211_hw *hw,
3127 unsigned int changed_flags,
3128 unsigned int *total_flags,
3129 u64 multicast)
3130{
3131 struct ath10k *ar = hw->priv;
3132 int ret;
3133
3134 mutex_lock(&ar->conf_mutex);
3135
3136 changed_flags &= SUPPORTED_FILTERS;
3137 *total_flags &= SUPPORTED_FILTERS;
3138 ar->filter_flags = *total_flags;
3139
1933747f
MK		 3140 ret = ath10k_monitor_recalc(ar);
3141 if (ret)
3142 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
5e3dd157
KV		 3143
3144 mutex_unlock(&ar->conf_mutex);
3145}
3146
3147static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
3148 struct ieee80211_vif *vif,
3149 struct ieee80211_bss_conf *info,
3150 u32 changed)
3151{
3152 struct ath10k *ar = hw->priv;
3153 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3154 int ret = 0;
af762c0b 3155 u32 vdev_param, pdev_param, slottime, preamble;
5e3dd157
KV		 3156
3157 mutex_lock(&ar->conf_mutex);
3158
3159 if (changed & BSS_CHANGED_IBSS)
3160 ath10k_control_ibss(arvif, info, vif->addr);
3161
3162 if (changed & BSS_CHANGED_BEACON_INT) {
3163 arvif->beacon_interval = info->beacon_int;
6d1506e7
BM		 3164 vdev_param = ar->wmi.vdev_param->beacon_interval;
3165 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157 3166 arvif->beacon_interval);
7aa7a72a 3167 ath10k_dbg(ar, ATH10K_DBG_MAC,
60c3daa8
KV		 3168 "mac vdev %d beacon_interval %d\n",
3169 arvif->vdev_id, arvif->beacon_interval);
3170
5e3dd157 3171 if (ret)
7aa7a72a 3172 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
69244e56 3173 arvif->vdev_id, ret);
5e3dd157
KV		 3174 }
3175
3176 if (changed & BSS_CHANGED_BEACON) {
7aa7a72a 3177 ath10k_dbg(ar, ATH10K_DBG_MAC,
60c3daa8
KV		 3178 "vdev %d set beacon tx mode to staggered\n",
3179 arvif->vdev_id);
3180
226a339b
BM		 3181 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
3182 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
5e3dd157
KV		 3183 WMI_BEACON_STAGGERED_MODE);
3184 if (ret)
7aa7a72a 3185 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
69244e56 3186 arvif->vdev_id, ret);
5e3dd157
KV		 3187 }
3188
b70727e8 3189 if (changed & BSS_CHANGED_BEACON_INFO) {
5e3dd157
KV		 3190 arvif->dtim_period = info->dtim_period;
3191
7aa7a72a 3192 ath10k_dbg(ar, ATH10K_DBG_MAC,
60c3daa8
KV		 3193 "mac vdev %d dtim_period %d\n",
3194 arvif->vdev_id, arvif->dtim_period);
3195
6d1506e7
BM		 3196 vdev_param = ar->wmi.vdev_param->dtim_period;
3197 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 3198 arvif->dtim_period);
3199 if (ret)
7aa7a72a 3200 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
69244e56 3201 arvif->vdev_id, ret);
5e3dd157
KV		 3202 }
3203
3204 if (changed & BSS_CHANGED_SSID &&
3205 vif->type == NL80211_IFTYPE_AP) {
3206 arvif->u.ap.ssid_len = info->ssid_len;
3207 if (info->ssid_len)
3208 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3209 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3210 }
3211
077efc8c
MK		 3212 if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
3213 ether_addr_copy(arvif->bssid, info->bssid);
5e3dd157
KV		 3214
3215 if (changed & BSS_CHANGED_BEACON_ENABLED)
3216 ath10k_control_beaconing(arvif, info);
3217
3218 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
e81bd104 3219 arvif->use_cts_prot = info->use_cts_prot;
7aa7a72a 3220 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
e81bd104 3221 arvif->vdev_id, info->use_cts_prot);
60c3daa8 3222
e81bd104 3223 ret = ath10k_recalc_rtscts_prot(arvif);
5e3dd157 3224 if (ret)
7aa7a72a 3225 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
69244e56 3226 arvif->vdev_id, ret);
5e3dd157
KV		 3227 }
3228
3229 if (changed & BSS_CHANGED_ERP_SLOT) {
5e3dd157
KV		 3230 if (info->use_short_slot)
3231 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3232
3233 else
3234 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3235
7aa7a72a 3236 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
60c3daa8
KV		 3237 arvif->vdev_id, slottime);
3238
6d1506e7
BM		 3239 vdev_param = ar->wmi.vdev_param->slot_time;
3240 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 3241 slottime);
3242 if (ret)
7aa7a72a 3243 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
69244e56 3244 arvif->vdev_id, ret);
5e3dd157
KV		 3245 }
3246
3247 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
5e3dd157
KV		 3248 if (info->use_short_preamble)
3249 preamble = WMI_VDEV_PREAMBLE_SHORT;
3250 else
3251 preamble = WMI_VDEV_PREAMBLE_LONG;
3252
7aa7a72a 3253 ath10k_dbg(ar, ATH10K_DBG_MAC,
60c3daa8
KV		 3254 "mac vdev %d preamble %dn",
3255 arvif->vdev_id, preamble);
3256
6d1506e7
BM		 3257 vdev_param = ar->wmi.vdev_param->preamble;
3258 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5e3dd157
KV		 3259 preamble);
3260 if (ret)
7aa7a72a 3261 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
69244e56 3262 arvif->vdev_id, ret);
5e3dd157
KV		 3263 }
3264
3265 if (changed & BSS_CHANGED_ASSOC) {
e556f111
MK		 3266 if (info->assoc) {
3267 /* Workaround: Make sure monitor vdev is not running
3268 * when associating to prevent some firmware revisions
3269 * (e.g. 10.1 and 10.2) from crashing.
3270 */
3271 if (ar->monitor_started)
3272 ath10k_monitor_stop(ar);
5e3dd157 3273 ath10k_bss_assoc(hw, vif, info);
e556f111 3274 ath10k_monitor_recalc(ar);
077efc8c
MK		 3275 } else {
3276 ath10k_bss_disassoc(hw, vif);
e556f111 3277 }
5e3dd157
KV		 3278 }
3279
7d9d5587
MK		 3280 if (changed & BSS_CHANGED_TXPOWER) {
3281 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
3282 arvif->vdev_id, info->txpower);
3283
3284 arvif->txpower = info->txpower;
3285 ret = ath10k_mac_txpower_recalc(ar);
3286 if (ret)
3287 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
3288 }
3289
5e3dd157
KV		 3290 mutex_unlock(&ar->conf_mutex);
3291}
3292
3293static int ath10k_hw_scan(struct ieee80211_hw *hw,
3294 struct ieee80211_vif *vif,
c56ef672 3295 struct ieee80211_scan_request *hw_req)
5e3dd157
KV		 3296{
3297 struct ath10k *ar = hw->priv;
3298 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
c56ef672 3299 struct cfg80211_scan_request *req = &hw_req->req;
5e3dd157
KV		 3300 struct wmi_start_scan_arg arg;
3301 int ret = 0;
3302 int i;
3303
3304 mutex_lock(&ar->conf_mutex);
3305
3306 spin_lock_bh(&ar->data_lock);
5c81c7fd
MK		 3307 switch (ar->scan.state) {
3308 case ATH10K_SCAN_IDLE:
3309 reinit_completion(&ar->scan.started);
3310 reinit_completion(&ar->scan.completed);
3311 ar->scan.state = ATH10K_SCAN_STARTING;
3312 ar->scan.is_roc = false;
3313 ar->scan.vdev_id = arvif->vdev_id;
3314 ret = 0;
3315 break;
3316 case ATH10K_SCAN_STARTING:
3317 case ATH10K_SCAN_RUNNING:
3318 case ATH10K_SCAN_ABORTING:
5e3dd157 3319 ret = -EBUSY;
5c81c7fd 3320 break;
5e3dd157 3321 }
5e3dd157
KV		 3322 spin_unlock_bh(&ar->data_lock);
3323
5c81c7fd
MK		 3324 if (ret)
3325 goto exit;
3326
5e3dd157
KV		 3327 memset(&arg, 0, sizeof(arg));
3328 ath10k_wmi_start_scan_init(ar, &arg);
3329 arg.vdev_id = arvif->vdev_id;
3330 arg.scan_id = ATH10K_SCAN_ID;
3331
3332 if (!req->no_cck)
3333 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3334
3335 if (req->ie_len) {
3336 arg.ie_len = req->ie_len;
3337 memcpy(arg.ie, req->ie, arg.ie_len);
3338 }
3339
3340 if (req->n_ssids) {
3341 arg.n_ssids = req->n_ssids;
3342 for (i = 0; i < arg.n_ssids; i++) {
3343 arg.ssids[i].len = req->ssids[i].ssid_len;
3344 arg.ssids[i].ssid = req->ssids[i].ssid;
3345 }
dcd4a561
MK		 3346 } else {
3347 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5e3dd157
KV		 3348 }
3349
3350 if (req->n_channels) {
3351 arg.n_channels = req->n_channels;
3352 for (i = 0; i < arg.n_channels; i++)
3353 arg.channels[i] = req->channels[i]->center_freq;
3354 }
3355
3356 ret = ath10k_start_scan(ar, &arg);
3357 if (ret) {
7aa7a72a 3358 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
5e3dd157 3359 spin_lock_bh(&ar->data_lock);
5c81c7fd 3360 ar->scan.state = ATH10K_SCAN_IDLE;
5e3dd157
KV		 3361 spin_unlock_bh(&ar->data_lock);
3362 }
3363
3364exit:
3365 mutex_unlock(&ar->conf_mutex);
3366 return ret;
3367}
3368
3369static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3370 struct ieee80211_vif *vif)
3371{
3372 struct ath10k *ar = hw->priv;
5e3dd157
KV		 3373
3374 mutex_lock(&ar->conf_mutex);
5c81c7fd 3375 ath10k_scan_abort(ar);
5e3dd157 3376 mutex_unlock(&ar->conf_mutex);
4eb2e164
MK		 3377
3378 cancel_delayed_work_sync(&ar->scan.timeout);
5e3dd157
KV		 3379}
3380
cfb27d29
MK		 3381static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3382 struct ath10k_vif *arvif,
3383 enum set_key_cmd cmd,
3384 struct ieee80211_key_conf *key)
3385{
3386 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3387 int ret;
3388
3389 /* 10.1 firmware branch requires default key index to be set to group
3390 * key index after installing it. Otherwise FW/HW Txes corrupted
3391 * frames with multi-vif APs. This is not required for main firmware
3392 * branch (e.g. 636).
3393 *
3394 * FIXME: This has been tested only in AP. It remains unknown if this
3395 * is required for multi-vif STA interfaces on 10.1 */
3396
3397 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3398 return;
3399
3400 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3401 return;
3402
3403 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3404 return;
3405
3406 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3407 return;
3408
3409 if (cmd != SET_KEY)
3410 return;
3411
3412 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3413 key->keyidx);
3414 if (ret)
7aa7a72a 3415 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
69244e56 3416 arvif->vdev_id, ret);
cfb27d29
MK		 3417}
3418
5e3dd157
KV		 3419static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3420 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3421 struct ieee80211_key_conf *key)
3422{
3423 struct ath10k *ar = hw->priv;
3424 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3425 struct ath10k_peer *peer;
3426 const u8 *peer_addr;
3427 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3428 key->cipher == WLAN_CIPHER_SUITE_WEP104;
3429 int ret = 0;
3430
3431 if (key->keyidx > WMI_MAX_KEY_INDEX)
3432 return -ENOSPC;
3433
3434 mutex_lock(&ar->conf_mutex);
3435
3436 if (sta)
3437 peer_addr = sta->addr;
3438 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3439 peer_addr = vif->bss_conf.bssid;
3440 else
3441 peer_addr = vif->addr;
3442
3443 key->hw_key_idx = key->keyidx;
3444
3445 /* the peer should not disappear in mid-way (unless FW goes awry) since
3446 * we already hold conf_mutex. we just make sure its there now. */
3447 spin_lock_bh(&ar->data_lock);
3448 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3449 spin_unlock_bh(&ar->data_lock);
3450
3451 if (!peer) {
3452 if (cmd == SET_KEY) {
7aa7a72a 3453 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
5e3dd157
KV		 3454 peer_addr);
3455 ret = -EOPNOTSUPP;
3456 goto exit;
3457 } else {
3458 /* if the peer doesn't exist there is no key to disable
3459 * anymore */
3460 goto exit;
3461 }
3462 }
3463
3464 if (is_wep) {
3465 if (cmd == SET_KEY)
3466 arvif->wep_keys[key->keyidx] = key;
3467 else
3468 arvif->wep_keys[key->keyidx] = NULL;
3469
3470 if (cmd == DISABLE_KEY)
3471 ath10k_clear_vdev_key(arvif, key);
3472 }
3473
3474 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3475 if (ret) {
7aa7a72a 3476 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
69244e56 3477 arvif->vdev_id, peer_addr, ret);
5e3dd157
KV		 3478 goto exit;
3479 }
3480
cfb27d29
MK		 3481 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3482
5e3dd157
KV		 3483 spin_lock_bh(&ar->data_lock);
3484 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3485 if (peer && cmd == SET_KEY)
3486 peer->keys[key->keyidx] = key;
3487 else if (peer && cmd == DISABLE_KEY)
3488 peer->keys[key->keyidx] = NULL;
3489 else if (peer == NULL)
3490 /* impossible unless FW goes crazy */
7aa7a72a 3491 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
5e3dd157
KV		 3492 spin_unlock_bh(&ar->data_lock);
3493
3494exit:
3495 mutex_unlock(&ar->conf_mutex);
3496 return ret;
3497}
3498
9797febc
MK		 3499static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3500{
3501 struct ath10k *ar;
3502 struct ath10k_vif *arvif;
3503 struct ath10k_sta *arsta;
3504 struct ieee80211_sta *sta;
3505 u32 changed, bw, nss, smps;
3506 int err;
3507
3508 arsta = container_of(wk, struct ath10k_sta, update_wk);
3509 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3510 arvif = arsta->arvif;
3511 ar = arvif->ar;
3512
3513 spin_lock_bh(&ar->data_lock);
3514
3515 changed = arsta->changed;
3516 arsta->changed = 0;
3517
3518 bw = arsta->bw;
3519 nss = arsta->nss;
3520 smps = arsta->smps;
3521
3522 spin_unlock_bh(&ar->data_lock);
3523
3524 mutex_lock(&ar->conf_mutex);
3525
3526 if (changed & IEEE80211_RC_BW_CHANGED) {
7aa7a72a 3527 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
9797febc
MK		 3528 sta->addr, bw);
3529
3530 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3531 WMI_PEER_CHAN_WIDTH, bw);
3532 if (err)
7aa7a72a 3533 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
9797febc
MK		 3534 sta->addr, bw, err);
3535 }
3536
3537 if (changed & IEEE80211_RC_NSS_CHANGED) {
7aa7a72a 3538 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
9797febc
MK		 3539 sta->addr, nss);
3540
3541 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3542 WMI_PEER_NSS, nss);
3543 if (err)
7aa7a72a 3544 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
9797febc
MK		 3545 sta->addr, nss, err);
3546 }
3547
3548 if (changed & IEEE80211_RC_SMPS_CHANGED) {
7aa7a72a 3549 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
9797febc
MK		 3550 sta->addr, smps);
3551
3552 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3553 WMI_PEER_SMPS_STATE, smps);
3554 if (err)
7aa7a72a 3555 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
9797febc
MK		 3556 sta->addr, smps, err);
3557 }
3558
44d6fa90 3559 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
7aa7a72a 3560 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
44d6fa90
CYY		 3561 sta->addr);
3562
590922a8 3563 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
44d6fa90 3564 if (err)
7aa7a72a 3565 ath10k_warn(ar, "failed to reassociate station: %pM\n",
44d6fa90
CYY		 3566 sta->addr);
3567 }
3568
9797febc
MK		 3569 mutex_unlock(&ar->conf_mutex);
3570}
3571
5e3dd157
KV		 3572static int ath10k_sta_state(struct ieee80211_hw *hw,
3573 struct ieee80211_vif *vif,
3574 struct ieee80211_sta *sta,
3575 enum ieee80211_sta_state old_state,
3576 enum ieee80211_sta_state new_state)
3577{
3578 struct ath10k *ar = hw->priv;
3579 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
9797febc 3580 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
0e759f36 3581 int max_num_peers;
5e3dd157
KV		 3582 int ret = 0;
3583
76f90024
MK		 3584 if (old_state == IEEE80211_STA_NOTEXIST &&
3585 new_state == IEEE80211_STA_NONE) {
3586 memset(arsta, 0, sizeof(*arsta));
3587 arsta->arvif = arvif;
3588 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3589 }
3590
9797febc
MK		 3591 /* cancel must be done outside the mutex to avoid deadlock */
3592 if ((old_state == IEEE80211_STA_NONE &&
3593 new_state == IEEE80211_STA_NOTEXIST))
3594 cancel_work_sync(&arsta->update_wk);
3595
5e3dd157
KV		 3596 mutex_lock(&ar->conf_mutex);
3597
3598 if (old_state == IEEE80211_STA_NOTEXIST &&
077efc8c 3599 new_state == IEEE80211_STA_NONE) {
5e3dd157
KV		 3600 /*
3601 * New station addition.
3602 */
0e759f36
BM		 3603 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3604 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3605 else
3606 max_num_peers = TARGET_NUM_PEERS;
3607
3608 if (ar->num_peers >= max_num_peers) {
7aa7a72a 3609 ath10k_warn(ar, "number of peers exceeded: peers number %d (max peers %d)\n",
0e759f36
BM		 3610 ar->num_peers, max_num_peers);
3611 ret = -ENOBUFS;
3612 goto exit;
3613 }
3614
7aa7a72a 3615 ath10k_dbg(ar, ATH10K_DBG_MAC,
0e759f36
BM		 3616 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3617 arvif->vdev_id, sta->addr, ar->num_peers);
60c3daa8 3618
5e3dd157
KV		 3619 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3620 if (ret)
7aa7a72a 3621 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
479398b0 3622 sta->addr, arvif->vdev_id, ret);
077efc8c
MK		 3623
3624 if (vif->type == NL80211_IFTYPE_STATION) {
3625 WARN_ON(arvif->is_started);
3626
3627 ret = ath10k_vdev_start(arvif);
3628 if (ret) {
3629 ath10k_warn(ar, "failed to start vdev %i: %d\n",
3630 arvif->vdev_id, ret);
3631 WARN_ON(ath10k_peer_delete(ar, arvif->vdev_id,
3632 sta->addr));
3633 goto exit;
3634 }
3635
3636 arvif->is_started = true;
3637 }
5e3dd157
KV		 3638 } else if ((old_state == IEEE80211_STA_NONE &&
3639 new_state == IEEE80211_STA_NOTEXIST)) {
3640 /*
3641 * Existing station deletion.
3642 */
7aa7a72a 3643 ath10k_dbg(ar, ATH10K_DBG_MAC,
60c3daa8
KV		 3644 "mac vdev %d peer delete %pM (sta gone)\n",
3645 arvif->vdev_id, sta->addr);
077efc8c
MK		 3646
3647 if (vif->type == NL80211_IFTYPE_STATION) {
3648 WARN_ON(!arvif->is_started);
3649
3650 ret = ath10k_vdev_stop(arvif);
3651 if (ret)
3652 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
3653 arvif->vdev_id, ret);
3654
3655 arvif->is_started = false;
3656 }
3657
5e3dd157
KV		 3658 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3659 if (ret)
7aa7a72a 3660 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
69244e56 3661 sta->addr, arvif->vdev_id, ret);
5e3dd157 3662
5e3dd157
KV		 3663 } else if (old_state == IEEE80211_STA_AUTH &&
3664 new_state == IEEE80211_STA_ASSOC &&
3665 (vif->type == NL80211_IFTYPE_AP ||
3666 vif->type == NL80211_IFTYPE_ADHOC)) {
3667 /*
3668 * New association.
3669 */
7aa7a72a 3670 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
60c3daa8
KV		 3671 sta->addr);
3672
590922a8 3673 ret = ath10k_station_assoc(ar, vif, sta, false);
5e3dd157 3674 if (ret)
7aa7a72a 3675 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
69244e56 3676 sta->addr, arvif->vdev_id, ret);
5e3dd157
KV		 3677 } else if (old_state == IEEE80211_STA_ASSOC &&
3678 new_state == IEEE80211_STA_AUTH &&
3679 (vif->type == NL80211_IFTYPE_AP ||
3680 vif->type == NL80211_IFTYPE_ADHOC)) {
3681 /*
3682 * Disassociation.
3683 */
7aa7a72a 3684 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
60c3daa8
KV		 3685 sta->addr);
3686
590922a8 3687 ret = ath10k_station_disassoc(ar, vif, sta);
5e3dd157 3688 if (ret)
7aa7a72a 3689 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
69244e56 3690 sta->addr, arvif->vdev_id, ret);
5e3dd157 3691 }
0e759f36 3692exit:
5e3dd157
KV		 3693 mutex_unlock(&ar->conf_mutex);
3694 return ret;
3695}
3696
3697static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5b07e07f 3698 u16 ac, bool enable)
5e3dd157
KV		 3699{
3700 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3701 u32 value = 0;
3702 int ret = 0;
3703
548db54c
MK		 3704 lockdep_assert_held(&ar->conf_mutex);
3705
5e3dd157
KV		 3706 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3707 return 0;
3708
3709 switch (ac) {
3710 case IEEE80211_AC_VO:
3711 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3712 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3713 break;
3714 case IEEE80211_AC_VI:
3715 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3716 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3717 break;
3718 case IEEE80211_AC_BE:
3719 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3720 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3721 break;
3722 case IEEE80211_AC_BK:
3723 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3724 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3725 break;
3726 }
3727
3728 if (enable)
3729 arvif->u.sta.uapsd |= value;
3730 else
3731 arvif->u.sta.uapsd &= ~value;
3732
3733 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3734 WMI_STA_PS_PARAM_UAPSD,
3735 arvif->u.sta.uapsd);
3736 if (ret) {
7aa7a72a 3737 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5e3dd157
KV		 3738 goto exit;
3739 }
3740
3741 if (arvif->u.sta.uapsd)
3742 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3743 else
3744 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3745
3746 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3747 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3748 value);
3749 if (ret)
7aa7a72a 3750 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5e3dd157
KV		 3751
3752exit:
3753 return ret;
3754}
3755
3756static int ath10k_conf_tx(struct ieee80211_hw *hw,
3757 struct ieee80211_vif *vif, u16 ac,
3758 const struct ieee80211_tx_queue_params *params)
3759{
3760 struct ath10k *ar = hw->priv;
3761 struct wmi_wmm_params_arg *p = NULL;
3762 int ret;
3763
3764 mutex_lock(&ar->conf_mutex);
3765
3766 switch (ac) {
3767 case IEEE80211_AC_VO:
3768 p = &ar->wmm_params.ac_vo;
3769 break;
3770 case IEEE80211_AC_VI:
3771 p = &ar->wmm_params.ac_vi;
3772 break;
3773 case IEEE80211_AC_BE:
3774 p = &ar->wmm_params.ac_be;
3775 break;
3776 case IEEE80211_AC_BK:
3777 p = &ar->wmm_params.ac_bk;
3778 break;
3779 }
3780
3781 if (WARN_ON(!p)) {
3782 ret = -EINVAL;
3783 goto exit;
3784 }
3785
3786 p->cwmin = params->cw_min;
3787 p->cwmax = params->cw_max;
3788 p->aifs = params->aifs;
3789
3790 /*
3791 * The channel time duration programmed in the HW is in absolute
3792 * microseconds, while mac80211 gives the txop in units of
3793 * 32 microseconds.
3794 */
3795 p->txop = params->txop * 32;
3796
3797 /* FIXME: FW accepts wmm params per hw, not per vif */
3798 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3799 if (ret) {
7aa7a72a 3800 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5e3dd157
KV		 3801 goto exit;
3802 }
3803
3804 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3805 if (ret)
7aa7a72a 3806 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5e3dd157
KV		 3807
3808exit:
3809 mutex_unlock(&ar->conf_mutex);
3810 return ret;
3811}
3812
3813#define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3814
3815static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3816 struct ieee80211_vif *vif,
3817 struct ieee80211_channel *chan,
3818 int duration,
3819 enum ieee80211_roc_type type)
3820{
3821 struct ath10k *ar = hw->priv;
3822 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3823 struct wmi_start_scan_arg arg;
5c81c7fd 3824 int ret = 0;
5e3dd157
KV		 3825
3826 mutex_lock(&ar->conf_mutex);
3827
3828 spin_lock_bh(&ar->data_lock);
5c81c7fd
MK		 3829 switch (ar->scan.state) {
3830 case ATH10K_SCAN_IDLE:
3831 reinit_completion(&ar->scan.started);
3832 reinit_completion(&ar->scan.completed);
3833 reinit_completion(&ar->scan.on_channel);
3834 ar->scan.state = ATH10K_SCAN_STARTING;
3835 ar->scan.is_roc = true;
3836 ar->scan.vdev_id = arvif->vdev_id;
3837 ar->scan.roc_freq = chan->center_freq;
3838 ret = 0;
3839 break;
3840 case ATH10K_SCAN_STARTING:
3841 case ATH10K_SCAN_RUNNING:
3842 case ATH10K_SCAN_ABORTING:
5e3dd157 3843 ret = -EBUSY;
5c81c7fd 3844 break;
5e3dd157 3845 }
5e3dd157
KV		 3846 spin_unlock_bh(&ar->data_lock);
3847
5c81c7fd
MK		 3848 if (ret)
3849 goto exit;
3850
dcca0bdb
MK		 3851 duration = max(duration, WMI_SCAN_CHAN_MIN_TIME_MSEC);
3852
5e3dd157
KV		 3853 memset(&arg, 0, sizeof(arg));
3854 ath10k_wmi_start_scan_init(ar, &arg);
3855 arg.vdev_id = arvif->vdev_id;
3856 arg.scan_id = ATH10K_SCAN_ID;
3857 arg.n_channels = 1;
3858 arg.channels[0] = chan->center_freq;
3859 arg.dwell_time_active = duration;
3860 arg.dwell_time_passive = duration;
3861 arg.max_scan_time = 2 * duration;
3862 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3863 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3864
3865 ret = ath10k_start_scan(ar, &arg);
3866 if (ret) {
7aa7a72a 3867 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5e3dd157 3868 spin_lock_bh(&ar->data_lock);
5c81c7fd 3869 ar->scan.state = ATH10K_SCAN_IDLE;
5e3dd157
KV		 3870 spin_unlock_bh(&ar->data_lock);
3871 goto exit;
3872 }
3873
3874 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3875 if (ret == 0) {
7aa7a72a 3876 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5c81c7fd
MK		 3877
3878 ret = ath10k_scan_stop(ar);
3879 if (ret)
7aa7a72a 3880 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5c81c7fd 3881
5e3dd157
KV		 3882 ret = -ETIMEDOUT;
3883 goto exit;
3884 }
3885
3886 ret = 0;
3887exit:
3888 mutex_unlock(&ar->conf_mutex);
3889 return ret;
3890}
3891
3892static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3893{
3894 struct ath10k *ar = hw->priv;
3895
3896 mutex_lock(&ar->conf_mutex);
5c81c7fd 3897 ath10k_scan_abort(ar);
5e3dd157
KV		 3898 mutex_unlock(&ar->conf_mutex);
3899
4eb2e164
MK		 3900 cancel_delayed_work_sync(&ar->scan.timeout);
3901
5e3dd157
KV		 3902 return 0;
3903}
3904
3905/*
3906 * Both RTS and Fragmentation threshold are interface-specific
3907 * in ath10k, but device-specific in mac80211.
3908 */
5e3dd157 3909
ad088bfa
MK		 3910static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3911{
3912 struct ath10k *ar = hw->priv;
3913 struct ath10k_vif *arvif;
3914 int ret = 0;
548db54c 3915
5e3dd157 3916 mutex_lock(&ar->conf_mutex);
ad088bfa 3917 list_for_each_entry(arvif, &ar->arvifs, list) {
7aa7a72a 3918 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
ad088bfa
MK		 3919 arvif->vdev_id, value);
3920
3921 ret = ath10k_mac_set_rts(arvif, value);
3922 if (ret) {
7aa7a72a 3923 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
ad088bfa
MK		 3924 arvif->vdev_id, ret);
3925 break;
3926 }
3927 }
5e3dd157
KV		 3928 mutex_unlock(&ar->conf_mutex);
3929
ad088bfa 3930 return ret;
5e3dd157
KV		 3931}
3932
ad088bfa 3933static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
5e3dd157 3934{
ad088bfa
MK		 3935 struct ath10k *ar = hw->priv;
3936 struct ath10k_vif *arvif;
3937 int ret = 0;
548db54c 3938
5e3dd157 3939 mutex_lock(&ar->conf_mutex);
ad088bfa 3940 list_for_each_entry(arvif, &ar->arvifs, list) {
7aa7a72a 3941 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
ad088bfa
MK		 3942 arvif->vdev_id, value);
3943
56a0dee7 3944 ret = ath10k_mac_set_frag(arvif, value);
ad088bfa 3945 if (ret) {
7aa7a72a 3946 ath10k_warn(ar, "failed to set fragmentation threshold for vdev %d: %d\n",
ad088bfa
MK		 3947 arvif->vdev_id, ret);
3948 break;
3949 }
3950 }
5e3dd157
KV		 3951 mutex_unlock(&ar->conf_mutex);
3952
ad088bfa 3953 return ret;
5e3dd157
KV		 3954}
3955
77be2c54
EG		 3956static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3957 u32 queues, bool drop)
5e3dd157
KV		 3958{
3959 struct ath10k *ar = hw->priv;
affd3217 3960 bool skip;
5e3dd157
KV		 3961 int ret;
3962
3963 /* mac80211 doesn't care if we really xmit queued frames or not
3964 * we'll collect those frames either way if we stop/delete vdevs */
3965 if (drop)
3966 return;
3967
548db54c
MK		 3968 mutex_lock(&ar->conf_mutex);
3969
affd3217
MK		 3970 if (ar->state == ATH10K_STATE_WEDGED)
3971 goto skip;
3972
edb8236d 3973 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
5e3dd157 3974 bool empty;
affd3217 3975
edb8236d 3976 spin_lock_bh(&ar->htt.tx_lock);
0945baf7 3977 empty = (ar->htt.num_pending_tx == 0);
edb8236d 3978 spin_unlock_bh(&ar->htt.tx_lock);
affd3217 3979
7962b0d8
MK		 3980 skip = (ar->state == ATH10K_STATE_WEDGED) ||
3981 test_bit(ATH10K_FLAG_CRASH_FLUSH,
3982 &ar->dev_flags);
affd3217
MK		 3983
3984 (empty || skip);
5e3dd157 3985 }), ATH10K_FLUSH_TIMEOUT_HZ);
affd3217
MK		 3986
3987 if (ret <= 0 || skip)
7aa7a72a 3988 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %i\n",
9ba4c787 3989 skip, ar->state, ret);
548db54c 3990
affd3217 3991skip:
548db54c 3992 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 3993}
3994
3995/* TODO: Implement this function properly
3996 * For now it is needed to reply to Probe Requests in IBSS mode.
3997 * Propably we need this information from FW.
3998 */
3999static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
4000{
4001 return 1;
4002}
4003
8cd13cad
MK		 4004#ifdef CONFIG_PM
4005static int ath10k_suspend(struct ieee80211_hw *hw,
4006 struct cfg80211_wowlan *wowlan)
4007{
4008 struct ath10k *ar = hw->priv;
4009 int ret;
4010
9042e17d
MP		 4011 mutex_lock(&ar->conf_mutex);
4012
00f5482b 4013 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
8cd13cad 4014 if (ret) {
00f5482b
MP		 4015 if (ret == -ETIMEDOUT)
4016 goto resume;
9042e17d
MP		 4017 ret = 1;
4018 goto exit;
8cd13cad
MK		 4019 }
4020
8cd13cad
MK		 4021 ret = ath10k_hif_suspend(ar);
4022 if (ret) {
7aa7a72a 4023 ath10k_warn(ar, "failed to suspend hif: %d\n", ret);
8cd13cad
MK		 4024 goto resume;
4025 }
4026
9042e17d
MP		 4027 ret = 0;
4028 goto exit;
8cd13cad
MK		 4029resume:
4030 ret = ath10k_wmi_pdev_resume_target(ar);
4031 if (ret)
7aa7a72a 4032 ath10k_warn(ar, "failed to resume target: %d\n", ret);
9042e17d
MP		 4033
4034 ret = 1;
4035exit:
4036 mutex_unlock(&ar->conf_mutex);
4037 return ret;
8cd13cad
MK		 4038}
4039
4040static int ath10k_resume(struct ieee80211_hw *hw)
4041{
4042 struct ath10k *ar = hw->priv;
4043 int ret;
4044
9042e17d
MP		 4045 mutex_lock(&ar->conf_mutex);
4046
8cd13cad
MK		 4047 ret = ath10k_hif_resume(ar);
4048 if (ret) {
7aa7a72a 4049 ath10k_warn(ar, "failed to resume hif: %d\n", ret);
9042e17d
MP		 4050 ret = 1;
4051 goto exit;
8cd13cad
MK		 4052 }
4053
4054 ret = ath10k_wmi_pdev_resume_target(ar);
4055 if (ret) {
7aa7a72a 4056 ath10k_warn(ar, "failed to resume target: %d\n", ret);
9042e17d
MP		 4057 ret = 1;
4058 goto exit;
8cd13cad
MK		 4059 }
4060
9042e17d
MP		 4061 ret = 0;
4062exit:
4063 mutex_unlock(&ar->conf_mutex);
4064 return ret;
8cd13cad
MK		 4065}
4066#endif
4067
cf2c92d8
EP		 4068static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
4069 enum ieee80211_reconfig_type reconfig_type)
affd3217
MK		 4070{
4071 struct ath10k *ar = hw->priv;
4072
cf2c92d8
EP		 4073 if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
4074 return;
4075
affd3217
MK		 4076 mutex_lock(&ar->conf_mutex);
4077
4078 /* If device failed to restart it will be in a different state, e.g.
4079 * ATH10K_STATE_WEDGED */
4080 if (ar->state == ATH10K_STATE_RESTARTED) {
7aa7a72a 4081 ath10k_info(ar, "device successfully recovered\n");
affd3217 4082 ar->state = ATH10K_STATE_ON;
7962b0d8 4083 ieee80211_wake_queues(ar->hw);
affd3217
MK		 4084 }
4085
4086 mutex_unlock(&ar->conf_mutex);
4087}
4088
2e1dea40
MK		 4089static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
4090 struct survey_info *survey)
4091{
4092 struct ath10k *ar = hw->priv;
4093 struct ieee80211_supported_band *sband;
4094 struct survey_info *ar_survey = &ar->survey[idx];
4095 int ret = 0;
4096
4097 mutex_lock(&ar->conf_mutex);
4098
4099 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
4100 if (sband && idx >= sband->n_channels) {
4101 idx -= sband->n_channels;
4102 sband = NULL;
4103 }
4104
4105 if (!sband)
4106 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
4107
4108 if (!sband || idx >= sband->n_channels) {
4109 ret = -ENOENT;
4110 goto exit;
4111 }
4112
4113 spin_lock_bh(&ar->data_lock);
4114 memcpy(survey, ar_survey, sizeof(*survey));
4115 spin_unlock_bh(&ar->data_lock);
4116
4117 survey->channel = &sband->channels[idx];
4118
fa1d4df8
FF		 4119 if (ar->rx_channel == survey->channel)
4120 survey->filled |= SURVEY_INFO_IN_USE;
4121
2e1dea40
MK		 4122exit:
4123 mutex_unlock(&ar->conf_mutex);
4124 return ret;
4125}
4126
51ab1a0a
JD		 4127/* Helper table for legacy fixed_rate/bitrate_mask */
4128static const u8 cck_ofdm_rate[] = {
4129 /* CCK */
4130 3, /* 1Mbps */
4131 2, /* 2Mbps */
4132 1, /* 5.5Mbps */
4133 0, /* 11Mbps */
4134 /* OFDM */
4135 3, /* 6Mbps */
4136 7, /* 9Mbps */
4137 2, /* 12Mbps */
4138 6, /* 18Mbps */
4139 1, /* 24Mbps */
4140 5, /* 36Mbps */
4141 0, /* 48Mbps */
4142 4, /* 54Mbps */
4143};
4144
4145/* Check if only one bit set */
4146static int ath10k_check_single_mask(u32 mask)
4147{
4148 int bit;
4149
4150 bit = ffs(mask);
4151 if (!bit)
4152 return 0;
4153
4154 mask &= ~BIT(bit - 1);
4155 if (mask)
4156 return 2;
4157
4158 return 1;
4159}
4160
4161static bool
4162ath10k_default_bitrate_mask(struct ath10k *ar,
4163 enum ieee80211_band band,
4164 const struct cfg80211_bitrate_mask *mask)
4165{
4166 u32 legacy = 0x00ff;
4167 u8 ht = 0xff, i;
4168 u16 vht = 0x3ff;
b116ea19
BG		 4169 u16 nrf = ar->num_rf_chains;
4170
4171 if (ar->cfg_tx_chainmask)
4172 nrf = get_nss_from_chainmask(ar->cfg_tx_chainmask);
51ab1a0a
JD		 4173
4174 switch (band) {
4175 case IEEE80211_BAND_2GHZ:
4176 legacy = 0x00fff;
4177 vht = 0;
4178 break;
4179 case IEEE80211_BAND_5GHZ:
4180 break;
4181 default:
4182 return false;
4183 }
4184
4185 if (mask->control[band].legacy != legacy)
4186 return false;
4187
b116ea19 4188 for (i = 0; i < nrf; i++)
51ab1a0a
JD		 4189 if (mask->control[band].ht_mcs[i] != ht)
4190 return false;
4191
b116ea19 4192 for (i = 0; i < nrf; i++)
51ab1a0a
JD		 4193 if (mask->control[band].vht_mcs[i] != vht)
4194 return false;
4195
4196 return true;
4197}
4198
4199static bool
4200ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
4201 enum ieee80211_band band,
4202 u8 *fixed_nss)
4203{
4204 int ht_nss = 0, vht_nss = 0, i;
4205
4206 /* check legacy */
4207 if (ath10k_check_single_mask(mask->control[band].legacy))
4208 return false;
4209
4210 /* check HT */
4211 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4212 if (mask->control[band].ht_mcs[i] == 0xff)
4213 continue;
4214 else if (mask->control[band].ht_mcs[i] == 0x00)
4215 break;
d8bb26b9
KV		 4216
4217 return false;
51ab1a0a
JD		 4218 }
4219
4220 ht_nss = i;
4221
4222 /* check VHT */
4223 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4224 if (mask->control[band].vht_mcs[i] == 0x03ff)
4225 continue;
4226 else if (mask->control[band].vht_mcs[i] == 0x0000)
4227 break;
d8bb26b9
KV		 4228
4229 return false;
51ab1a0a
JD		 4230 }
4231
4232 vht_nss = i;
4233
4234 if (ht_nss > 0 && vht_nss > 0)
4235 return false;
4236
4237 if (ht_nss)
4238 *fixed_nss = ht_nss;
4239 else if (vht_nss)
4240 *fixed_nss = vht_nss;
4241 else
4242 return false;
4243
4244 return true;
4245}
4246
4247static bool
4248ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4249 enum ieee80211_band band,
4250 enum wmi_rate_preamble *preamble)
4251{
4252 int legacy = 0, ht = 0, vht = 0, i;
4253
4254 *preamble = WMI_RATE_PREAMBLE_OFDM;
4255
4256 /* check legacy */
4257 legacy = ath10k_check_single_mask(mask->control[band].legacy);
4258 if (legacy > 1)
4259 return false;
4260
4261 /* check HT */
4262 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4263 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4264 if (ht > 1)
4265 return false;
4266
4267 /* check VHT */
4268 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4269 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4270 if (vht > 1)
4271 return false;
4272
4273 /* Currently we support only one fixed_rate */
4274 if ((legacy + ht + vht) != 1)
4275 return false;
4276
4277 if (ht)
4278 *preamble = WMI_RATE_PREAMBLE_HT;
4279 else if (vht)
4280 *preamble = WMI_RATE_PREAMBLE_VHT;
4281
4282 return true;
4283}
4284
4285static bool
7aa7a72a
MK		 4286ath10k_bitrate_mask_rate(struct ath10k *ar,
4287 const struct cfg80211_bitrate_mask *mask,
51ab1a0a
JD		 4288 enum ieee80211_band band,
4289 u8 *fixed_rate,
4290 u8 *fixed_nss)
4291{
4292 u8 rate = 0, pream = 0, nss = 0, i;
4293 enum wmi_rate_preamble preamble;
4294
4295 /* Check if single rate correct */
4296 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4297 return false;
4298
4299 pream = preamble;
4300
4301 switch (preamble) {
4302 case WMI_RATE_PREAMBLE_CCK:
4303 case WMI_RATE_PREAMBLE_OFDM:
4304 i = ffs(mask->control[band].legacy) - 1;
4305
4306 if (band == IEEE80211_BAND_2GHZ && i < 4)
4307 pream = WMI_RATE_PREAMBLE_CCK;
4308
4309 if (band == IEEE80211_BAND_5GHZ)
4310 i += 4;
4311
4312 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4313 return false;
4314
4315 rate = cck_ofdm_rate[i];
4316 break;
4317 case WMI_RATE_PREAMBLE_HT:
4318 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4319 if (mask->control[band].ht_mcs[i])
4320 break;
4321
4322 if (i == IEEE80211_HT_MCS_MASK_LEN)
4323 return false;
4324
4325 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4326 nss = i;
4327 break;
4328 case WMI_RATE_PREAMBLE_VHT:
4329 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4330 if (mask->control[band].vht_mcs[i])
4331 break;
4332
4333 if (i == NL80211_VHT_NSS_MAX)
4334 return false;
4335
4336 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4337 nss = i;
4338 break;
4339 }
4340
4341 *fixed_nss = nss + 1;
4342 nss <<= 4;
4343 pream <<= 6;
4344
7aa7a72a 4345 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
51ab1a0a
JD		 4346 pream, nss, rate);
4347
4348 *fixed_rate = pream | nss | rate;
4349
4350 return true;
4351}
4352
7aa7a72a
MK		 4353static bool ath10k_get_fixed_rate_nss(struct ath10k *ar,
4354 const struct cfg80211_bitrate_mask *mask,
51ab1a0a
JD		 4355 enum ieee80211_band band,
4356 u8 *fixed_rate,
4357 u8 *fixed_nss)
4358{
4359 /* First check full NSS mask, if we can simply limit NSS */
4360 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4361 return true;
4362
4363 /* Next Check single rate is set */
7aa7a72a 4364 return ath10k_bitrate_mask_rate(ar, mask, band, fixed_rate, fixed_nss);
51ab1a0a
JD		 4365}
4366
4367static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4368 u8 fixed_rate,
9f81f725
JD		 4369 u8 fixed_nss,
4370 u8 force_sgi)
51ab1a0a
JD		 4371{
4372 struct ath10k *ar = arvif->ar;
4373 u32 vdev_param;
4374 int ret = 0;
4375
4376 mutex_lock(&ar->conf_mutex);
4377
4378 if (arvif->fixed_rate == fixed_rate &&
9f81f725
JD		 4379 arvif->fixed_nss == fixed_nss &&
4380 arvif->force_sgi == force_sgi)
51ab1a0a
JD		 4381 goto exit;
4382
4383 if (fixed_rate == WMI_FIXED_RATE_NONE)
7aa7a72a 4384 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
51ab1a0a 4385
9f81f725 4386 if (force_sgi)
7aa7a72a 4387 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac force sgi\n");
9f81f725 4388
51ab1a0a
JD		 4389 vdev_param = ar->wmi.vdev_param->fixed_rate;
4390 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4391 vdev_param, fixed_rate);
4392 if (ret) {
7aa7a72a 4393 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
51ab1a0a
JD		 4394 fixed_rate, ret);
4395 ret = -EINVAL;
4396 goto exit;
4397 }
4398
4399 arvif->fixed_rate = fixed_rate;
4400
4401 vdev_param = ar->wmi.vdev_param->nss;
4402 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4403 vdev_param, fixed_nss);
4404
4405 if (ret) {
7aa7a72a 4406 ath10k_warn(ar, "failed to set fixed nss param %d: %d\n",
51ab1a0a
JD		 4407 fixed_nss, ret);
4408 ret = -EINVAL;
4409 goto exit;
4410 }
4411
4412 arvif->fixed_nss = fixed_nss;
4413
9f81f725
JD		 4414 vdev_param = ar->wmi.vdev_param->sgi;
4415 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4416 force_sgi);
4417
4418 if (ret) {
7aa7a72a 4419 ath10k_warn(ar, "failed to set sgi param %d: %d\n",
9f81f725
JD		 4420 force_sgi, ret);
4421 ret = -EINVAL;
4422 goto exit;
4423 }
4424
4425 arvif->force_sgi = force_sgi;
4426
51ab1a0a
JD		 4427exit:
4428 mutex_unlock(&ar->conf_mutex);
4429 return ret;
4430}
4431
4432static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4433 struct ieee80211_vif *vif,
4434 const struct cfg80211_bitrate_mask *mask)
4435{
4436 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4437 struct ath10k *ar = arvif->ar;
4438 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4439 u8 fixed_rate = WMI_FIXED_RATE_NONE;
4440 u8 fixed_nss = ar->num_rf_chains;
9f81f725
JD		 4441 u8 force_sgi;
4442
b116ea19
BG		 4443 if (ar->cfg_tx_chainmask)
4444 fixed_nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4445
9f81f725
JD		 4446 force_sgi = mask->control[band].gi;
4447 if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4448 return -EINVAL;
51ab1a0a
JD		 4449
4450 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
7aa7a72a 4451 if (!ath10k_get_fixed_rate_nss(ar, mask, band,
51ab1a0a
JD		 4452 &fixed_rate,
4453 &fixed_nss))
4454 return -EINVAL;
4455 }
4456
9f81f725 4457 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
7aa7a72a 4458 ath10k_warn(ar, "failed to force SGI usage for default rate settings\n");
9f81f725
JD		 4459 return -EINVAL;
4460 }
4461
4462 return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4463 fixed_nss, force_sgi);
51ab1a0a
JD		 4464}
4465
9797febc
MK		 4466static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4467 struct ieee80211_vif *vif,
4468 struct ieee80211_sta *sta,
4469 u32 changed)
4470{
4471 struct ath10k *ar = hw->priv;
4472 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4473 u32 bw, smps;
4474
4475 spin_lock_bh(&ar->data_lock);
4476
7aa7a72a 4477 ath10k_dbg(ar, ATH10K_DBG_MAC,
9797febc
MK		 4478 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4479 sta->addr, changed, sta->bandwidth, sta->rx_nss,
4480 sta->smps_mode);
4481
4482 if (changed & IEEE80211_RC_BW_CHANGED) {
4483 bw = WMI_PEER_CHWIDTH_20MHZ;
4484
4485 switch (sta->bandwidth) {
4486 case IEEE80211_STA_RX_BW_20:
4487 bw = WMI_PEER_CHWIDTH_20MHZ;
4488 break;
4489 case IEEE80211_STA_RX_BW_40:
4490 bw = WMI_PEER_CHWIDTH_40MHZ;
4491 break;
4492 case IEEE80211_STA_RX_BW_80:
4493 bw = WMI_PEER_CHWIDTH_80MHZ;
4494 break;
4495 case IEEE80211_STA_RX_BW_160:
7aa7a72a 4496 ath10k_warn(ar, "Invalid bandwith %d in rc update for %pM\n",
be6546fc 4497 sta->bandwidth, sta->addr);
9797febc
MK		 4498 bw = WMI_PEER_CHWIDTH_20MHZ;
4499 break;
4500 }
4501
4502 arsta->bw = bw;
4503 }
4504
4505 if (changed & IEEE80211_RC_NSS_CHANGED)
4506 arsta->nss = sta->rx_nss;
4507
4508 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4509 smps = WMI_PEER_SMPS_PS_NONE;
4510
4511 switch (sta->smps_mode) {
4512 case IEEE80211_SMPS_AUTOMATIC:
4513 case IEEE80211_SMPS_OFF:
4514 smps = WMI_PEER_SMPS_PS_NONE;
4515 break;
4516 case IEEE80211_SMPS_STATIC:
4517 smps = WMI_PEER_SMPS_STATIC;
4518 break;
4519 case IEEE80211_SMPS_DYNAMIC:
4520 smps = WMI_PEER_SMPS_DYNAMIC;
4521 break;
4522 case IEEE80211_SMPS_NUM_MODES:
7aa7a72a 4523 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
be6546fc 4524 sta->smps_mode, sta->addr);
9797febc
MK		 4525 smps = WMI_PEER_SMPS_PS_NONE;
4526 break;
4527 }
4528
4529 arsta->smps = smps;
4530 }
4531
9797febc
MK		 4532 arsta->changed |= changed;
4533
4534 spin_unlock_bh(&ar->data_lock);
4535
4536 ieee80211_queue_work(hw, &arsta->update_wk);
4537}
4538
26ebbccf
CYY		 4539static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4540{
4541 /*
4542 * FIXME: Return 0 for time being. Need to figure out whether FW
4543 * has the API to fetch 64-bit local TSF
4544 */
4545
4546 return 0;
4547}
4548
aa5b4fbc
MK		 4549static int ath10k_ampdu_action(struct ieee80211_hw *hw,
4550 struct ieee80211_vif *vif,
4551 enum ieee80211_ampdu_mlme_action action,
4552 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4553 u8 buf_size)
4554{
7aa7a72a 4555 struct ath10k *ar = hw->priv;
aa5b4fbc
MK		 4556 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4557
7aa7a72a 4558 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
aa5b4fbc
MK		 4559 arvif->vdev_id, sta->addr, tid, action);
4560
4561 switch (action) {
4562 case IEEE80211_AMPDU_RX_START:
4563 case IEEE80211_AMPDU_RX_STOP:
4564 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
4565 * creation/removal. Do we need to verify this?
4566 */
4567 return 0;
4568 case IEEE80211_AMPDU_TX_START:
4569 case IEEE80211_AMPDU_TX_STOP_CONT:
4570 case IEEE80211_AMPDU_TX_STOP_FLUSH:
4571 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
4572 case IEEE80211_AMPDU_TX_OPERATIONAL:
4573 /* Firmware offloads Tx aggregation entirely so deny mac80211
4574 * Tx aggregation requests.
4575 */
4576 return -EOPNOTSUPP;
4577 }
4578
4579 return -EINVAL;
4580}
4581
5e3dd157
KV		 4582static const struct ieee80211_ops ath10k_ops = {
4583 .tx = ath10k_tx,
4584 .start = ath10k_start,
4585 .stop = ath10k_stop,
4586 .config = ath10k_config,
4587 .add_interface = ath10k_add_interface,
4588 .remove_interface = ath10k_remove_interface,
4589 .configure_filter = ath10k_configure_filter,
4590 .bss_info_changed = ath10k_bss_info_changed,
4591 .hw_scan = ath10k_hw_scan,
4592 .cancel_hw_scan = ath10k_cancel_hw_scan,
4593 .set_key = ath10k_set_key,
4594 .sta_state = ath10k_sta_state,
4595 .conf_tx = ath10k_conf_tx,
4596 .remain_on_channel = ath10k_remain_on_channel,
4597 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
4598 .set_rts_threshold = ath10k_set_rts_threshold,
4599 .set_frag_threshold = ath10k_set_frag_threshold,
4600 .flush = ath10k_flush,
4601 .tx_last_beacon = ath10k_tx_last_beacon,
46acf7bb
BG		 4602 .set_antenna = ath10k_set_antenna,
4603 .get_antenna = ath10k_get_antenna,
cf2c92d8 4604 .reconfig_complete = ath10k_reconfig_complete,
2e1dea40 4605 .get_survey = ath10k_get_survey,
51ab1a0a 4606 .set_bitrate_mask = ath10k_set_bitrate_mask,
9797febc 4607 .sta_rc_update = ath10k_sta_rc_update,
26ebbccf 4608 .get_tsf = ath10k_get_tsf,
aa5b4fbc 4609 .ampdu_action = ath10k_ampdu_action,
6cddcc7a
BG		 4610 .get_et_sset_count = ath10k_debug_get_et_sset_count,
4611 .get_et_stats = ath10k_debug_get_et_stats,
4612 .get_et_strings = ath10k_debug_get_et_strings,
43d2a30f
KV		 4613
4614 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
4615
8cd13cad
MK		 4616#ifdef CONFIG_PM
4617 .suspend = ath10k_suspend,
4618 .resume = ath10k_resume,
4619#endif
5e3dd157
KV		 4620};
4621
4622#define RATETAB_ENT(_rate, _rateid, _flags) { \
4623 .bitrate = (_rate), \
4624 .flags = (_flags), \
4625 .hw_value = (_rateid), \
4626}
4627
4628#define CHAN2G(_channel, _freq, _flags) { \
4629 .band = IEEE80211_BAND_2GHZ, \
4630 .hw_value = (_channel), \
4631 .center_freq = (_freq), \
4632 .flags = (_flags), \
4633 .max_antenna_gain = 0, \
4634 .max_power = 30, \
4635}
4636
4637#define CHAN5G(_channel, _freq, _flags) { \
4638 .band = IEEE80211_BAND_5GHZ, \
4639 .hw_value = (_channel), \
4640 .center_freq = (_freq), \
4641 .flags = (_flags), \
4642 .max_antenna_gain = 0, \
4643 .max_power = 30, \
4644}
4645
4646static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4647 CHAN2G(1, 2412, 0),
4648 CHAN2G(2, 2417, 0),
4649 CHAN2G(3, 2422, 0),
4650 CHAN2G(4, 2427, 0),
4651 CHAN2G(5, 2432, 0),
4652 CHAN2G(6, 2437, 0),
4653 CHAN2G(7, 2442, 0),
4654 CHAN2G(8, 2447, 0),
4655 CHAN2G(9, 2452, 0),
4656 CHAN2G(10, 2457, 0),
4657 CHAN2G(11, 2462, 0),
4658 CHAN2G(12, 2467, 0),
4659 CHAN2G(13, 2472, 0),
4660 CHAN2G(14, 2484, 0),
4661};
4662
4663static const struct ieee80211_channel ath10k_5ghz_channels[] = {
429ff56a
MK		 4664 CHAN5G(36, 5180, 0),
4665 CHAN5G(40, 5200, 0),
4666 CHAN5G(44, 5220, 0),
4667 CHAN5G(48, 5240, 0),
4668 CHAN5G(52, 5260, 0),
4669 CHAN5G(56, 5280, 0),
4670 CHAN5G(60, 5300, 0),
4671 CHAN5G(64, 5320, 0),
4672 CHAN5G(100, 5500, 0),
4673 CHAN5G(104, 5520, 0),
4674 CHAN5G(108, 5540, 0),
4675 CHAN5G(112, 5560, 0),
4676 CHAN5G(116, 5580, 0),
4677 CHAN5G(120, 5600, 0),
4678 CHAN5G(124, 5620, 0),
4679 CHAN5G(128, 5640, 0),
4680 CHAN5G(132, 5660, 0),
4681 CHAN5G(136, 5680, 0),
4682 CHAN5G(140, 5700, 0),
4683 CHAN5G(149, 5745, 0),
4684 CHAN5G(153, 5765, 0),
4685 CHAN5G(157, 5785, 0),
4686 CHAN5G(161, 5805, 0),
4687 CHAN5G(165, 5825, 0),
5e3dd157
KV		 4688};
4689
4690static struct ieee80211_rate ath10k_rates[] = {
4691 /* CCK */
4692 RATETAB_ENT(10, 0x82, 0),
4693 RATETAB_ENT(20, 0x84, 0),
4694 RATETAB_ENT(55, 0x8b, 0),
4695 RATETAB_ENT(110, 0x96, 0),
4696 /* OFDM */
4697 RATETAB_ENT(60, 0x0c, 0),
4698 RATETAB_ENT(90, 0x12, 0),
4699 RATETAB_ENT(120, 0x18, 0),
4700 RATETAB_ENT(180, 0x24, 0),
4701 RATETAB_ENT(240, 0x30, 0),
4702 RATETAB_ENT(360, 0x48, 0),
4703 RATETAB_ENT(480, 0x60, 0),
4704 RATETAB_ENT(540, 0x6c, 0),
4705};
4706
4707#define ath10k_a_rates (ath10k_rates + 4)
4708#define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4709#define ath10k_g_rates (ath10k_rates + 0)
4710#define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4711
e7b54194 4712struct ath10k *ath10k_mac_create(size_t priv_size)
5e3dd157
KV		 4713{
4714 struct ieee80211_hw *hw;
4715 struct ath10k *ar;
4716
e7b54194 4717 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
5e3dd157
KV		 4718 if (!hw)
4719 return NULL;
4720
4721 ar = hw->priv;
4722 ar->hw = hw;
4723
4724 return ar;
4725}
4726
4727void ath10k_mac_destroy(struct ath10k *ar)
4728{
4729 ieee80211_free_hw(ar->hw);
4730}
4731
4732static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4733 {
4734 .max = 8,
4735 .types = BIT(NL80211_IFTYPE_STATION)
4736 | BIT(NL80211_IFTYPE_P2P_CLIENT)
d531cb85
MK		 4737 },
4738 {
4739 .max = 3,
4740 .types = BIT(NL80211_IFTYPE_P2P_GO)
4741 },
4742 {
4743 .max = 7,
4744 .types = BIT(NL80211_IFTYPE_AP)
4745 },
5e3dd157
KV		 4746};
4747
f259509b 4748static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
e8a50f8b
MP		 4749 {
4750 .max = 8,
4751 .types = BIT(NL80211_IFTYPE_AP)
4752 },
4753};
e8a50f8b
MP		 4754
4755static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4756 {
4757 .limits = ath10k_if_limits,
4758 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4759 .max_interfaces = 8,
4760 .num_different_channels = 1,
4761 .beacon_int_infra_match = true,
4762 },
f259509b
BM		 4763};
4764
4765static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
e8a50f8b 4766 {
f259509b
BM		 4767 .limits = ath10k_10x_if_limits,
4768 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
e8a50f8b
MP		 4769 .max_interfaces = 8,
4770 .num_different_channels = 1,
4771 .beacon_int_infra_match = true,
f259509b 4772#ifdef CONFIG_ATH10K_DFS_CERTIFIED
e8a50f8b
MP		 4773 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4774 BIT(NL80211_CHAN_WIDTH_20) |
4775 BIT(NL80211_CHAN_WIDTH_40) |
4776 BIT(NL80211_CHAN_WIDTH_80),
e8a50f8b 4777#endif
f259509b 4778 },
5e3dd157
KV		 4779};
4780
4781static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4782{
4783 struct ieee80211_sta_vht_cap vht_cap = {0};
4784 u16 mcs_map;
8865bee4 4785 int i;
5e3dd157
KV		 4786
4787 vht_cap.vht_supported = 1;
4788 vht_cap.cap = ar->vht_cap_info;
4789
8865bee4
MK		 4790 mcs_map = 0;
4791 for (i = 0; i < 8; i++) {
4792 if (i < ar->num_rf_chains)
4793 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4794 else
4795 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4796 }
5e3dd157
KV		 4797
4798 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4799 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4800
4801 return vht_cap;
4802}
4803
4804static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4805{
4806 int i;
4807 struct ieee80211_sta_ht_cap ht_cap = {0};
4808
4809 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4810 return ht_cap;
4811
4812 ht_cap.ht_supported = 1;
4813 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4814 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4815 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4816 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4817 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4818
4819 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4820 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4821
4822 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4823 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4824
4825 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4826 u32 smps;
4827
4828 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4829 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4830
4831 ht_cap.cap |= smps;
4832 }
4833
4834 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4835 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4836
4837 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4838 u32 stbc;
4839
4840 stbc = ar->ht_cap_info;
4841 stbc &= WMI_HT_CAP_RX_STBC;
4842 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4843 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4844 stbc &= IEEE80211_HT_CAP_RX_STBC;
4845
4846 ht_cap.cap |= stbc;
4847 }
4848
4849 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4850 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4851
4852 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4853 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4854
4855 /* max AMSDU is implicitly taken from vht_cap_info */
4856 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4857 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4858
8865bee4 4859 for (i = 0; i < ar->num_rf_chains; i++)
5e3dd157
KV		 4860 ht_cap.mcs.rx_mask[i] = 0xFF;
4861
4862 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4863
4864 return ht_cap;
4865}
4866
5e3dd157
KV		 4867static void ath10k_get_arvif_iter(void *data, u8 *mac,
4868 struct ieee80211_vif *vif)
4869{
4870 struct ath10k_vif_iter *arvif_iter = data;
4871 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4872
4873 if (arvif->vdev_id == arvif_iter->vdev_id)
4874 arvif_iter->arvif = arvif;
4875}
4876
4877struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4878{
4879 struct ath10k_vif_iter arvif_iter;
4880 u32 flags;
4881
4882 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4883 arvif_iter.vdev_id = vdev_id;
4884
4885 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4886 ieee80211_iterate_active_interfaces_atomic(ar->hw,
4887 flags,
4888 ath10k_get_arvif_iter,
4889 &arvif_iter);
4890 if (!arvif_iter.arvif) {
7aa7a72a 4891 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
5e3dd157
KV		 4892 return NULL;
4893 }
4894
4895 return arvif_iter.arvif;
4896}
4897
4898int ath10k_mac_register(struct ath10k *ar)
4899{
4900 struct ieee80211_supported_band *band;
4901 struct ieee80211_sta_vht_cap vht_cap;
4902 struct ieee80211_sta_ht_cap ht_cap;
4903 void *channels;
4904 int ret;
4905
4906 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4907
4908 SET_IEEE80211_DEV(ar->hw, ar->dev);
4909
4910 ht_cap = ath10k_get_ht_cap(ar);
4911 vht_cap = ath10k_create_vht_cap(ar);
4912
4913 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4914 channels = kmemdup(ath10k_2ghz_channels,
4915 sizeof(ath10k_2ghz_channels),
4916 GFP_KERNEL);
d6015b27
MK		 4917 if (!channels) {
4918 ret = -ENOMEM;
4919 goto err_free;
4920 }
5e3dd157
KV		 4921
4922 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4923 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4924 band->channels = channels;
4925 band->n_bitrates = ath10k_g_rates_size;
4926 band->bitrates = ath10k_g_rates;
4927 band->ht_cap = ht_cap;
4928
4929 /* vht is not supported in 2.4 GHz */
4930
4931 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4932 }
4933
4934 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4935 channels = kmemdup(ath10k_5ghz_channels,
4936 sizeof(ath10k_5ghz_channels),
4937 GFP_KERNEL);
4938 if (!channels) {
d6015b27
MK		 4939 ret = -ENOMEM;
4940 goto err_free;
5e3dd157
KV		 4941 }
4942
4943 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4944 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4945 band->channels = channels;
4946 band->n_bitrates = ath10k_a_rates_size;
4947 band->bitrates = ath10k_a_rates;
4948 band->ht_cap = ht_cap;
4949 band->vht_cap = vht_cap;
4950 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4951 }
4952
4953 ar->hw->wiphy->interface_modes =
4954 BIT(NL80211_IFTYPE_STATION) |
d354181f
BM		 4955 BIT(NL80211_IFTYPE_AP);
4956
46acf7bb
BG		 4957 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
4958 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
4959
d354181f
BM		 4960 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4961 ar->hw->wiphy->interface_modes |=
4962 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4963 BIT(NL80211_IFTYPE_P2P_GO);
5e3dd157
KV		 4964
4965 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4966 IEEE80211_HW_SUPPORTS_PS |
4967 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4968 IEEE80211_HW_SUPPORTS_UAPSD |
4969 IEEE80211_HW_MFP_CAPABLE |
4970 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4971 IEEE80211_HW_HAS_RATE_CONTROL |
2f0f1121
JD		 4972 IEEE80211_HW_AP_LINK_PS |
4973 IEEE80211_HW_SPECTRUM_MGMT;
5e3dd157 4974
0d8614b4
EP		 4975 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
4976
5e3dd157 4977 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
0d8614b4 4978 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
5e3dd157
KV		 4979
4980 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4981 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4982 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4983 }
4984
4985 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4986 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4987
4988 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
9797febc 4989 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
5e3dd157 4990
5e3dd157
KV		 4991 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4992
4993 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
c2df44b3 4994 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
5e3dd157
KV		 4995 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4996
4997 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
78157a1c
RM		 4998 ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
4999
5e3dd157
KV		 5000 /*
5001 * on LL hardware queues are managed entirely by the FW
5002 * so we only advertise to mac we can do the queues thing
5003 */
5004 ar->hw->queues = 4;
5005
f259509b
BM		 5006 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
5007 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
5008 ar->hw->wiphy->n_iface_combinations =
5009 ARRAY_SIZE(ath10k_10x_if_comb);
5010 } else {
5011 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
5012 ar->hw->wiphy->n_iface_combinations =
5013 ARRAY_SIZE(ath10k_if_comb);
cf850d1d
MK		 5014
5015 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
f259509b 5016 }
5e3dd157 5017
7c199997
MK		 5018 ar->hw->netdev_features = NETIF_F_HW_CSUM;
5019
9702c686
JD		 5020 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
5021 /* Init ath dfs pattern detector */
5022 ar->ath_common.debug_mask = ATH_DBG_DFS;
5023 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
5024 NL80211_DFS_UNSET);
5025
5026 if (!ar->dfs_detector)
7aa7a72a 5027 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
9702c686
JD		 5028 }
5029
5e3dd157
KV		 5030 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
5031 ath10k_reg_notifier);
5032 if (ret) {
7aa7a72a 5033 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
d6015b27 5034 goto err_free;
5e3dd157
KV		 5035 }
5036
5037 ret = ieee80211_register_hw(ar->hw);
5038 if (ret) {
7aa7a72a 5039 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
d6015b27 5040 goto err_free;
5e3dd157
KV		 5041 }
5042
5043 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
5044 ret = regulatory_hint(ar->hw->wiphy,
5045 ar->ath_common.regulatory.alpha2);
5046 if (ret)
d6015b27 5047 goto err_unregister;
5e3dd157
KV		 5048 }
5049
5050 return 0;
d6015b27
MK		 5051
5052err_unregister:
5e3dd157 5053 ieee80211_unregister_hw(ar->hw);
d6015b27
MK		 5054err_free:
5055 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5056 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5057
5e3dd157
KV		 5058 return ret;
5059}
5060
5061void ath10k_mac_unregister(struct ath10k *ar)
5062{
5063 ieee80211_unregister_hw(ar->hw);
5064
9702c686
JD		 5065 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
5066 ar->dfs_detector->exit(ar->dfs_detector);
5067
5e3dd157
KV		 5068 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
5069 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
5070
5071 SET_IEEE80211_DEV(ar->hw, NULL);
5072}
Linux kernel - Deliverables
This page took 1.162886 seconds and 5 git commands to generate.