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