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