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