projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath10k: improve tx throughput on slow machines
[deliverable/linux.git] / drivers / net / wireless / ath / ath10k / mac.c
CommitLineData
5e3dd157
KV		 1/*
2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18#include "mac.h"
19
20#include <net/mac80211.h>
21#include <linux/etherdevice.h>
22
8cd13cad 23#include "hif.h"
5e3dd157
KV		 24#include "core.h"
25#include "debug.h"
26#include "wmi.h"
27#include "htt.h"
28#include "txrx.h"
29
30/**********/
31/* Crypto */
32/**********/
33
34static int ath10k_send_key(struct ath10k_vif *arvif,
35 struct ieee80211_key_conf *key,
36 enum set_key_cmd cmd,
37 const u8 *macaddr)
38{
39 struct wmi_vdev_install_key_arg arg = {
40 .vdev_id = arvif->vdev_id,
41 .key_idx = key->keyidx,
42 .key_len = key->keylen,
43 .key_data = key->key,
44 .macaddr = macaddr,
45 };
46
548db54c
MK		 47 lockdep_assert_held(&arvif->ar->conf_mutex);
48
5e3dd157
KV		 49 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
50 arg.key_flags = WMI_KEY_PAIRWISE;
51 else
52 arg.key_flags = WMI_KEY_GROUP;
53
54 switch (key->cipher) {
55 case WLAN_CIPHER_SUITE_CCMP:
56 arg.key_cipher = WMI_CIPHER_AES_CCM;
57 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
58 break;
59 case WLAN_CIPHER_SUITE_TKIP:
5e3dd157
KV		 60 arg.key_cipher = WMI_CIPHER_TKIP;
61 arg.key_txmic_len = 8;
62 arg.key_rxmic_len = 8;
63 break;
64 case WLAN_CIPHER_SUITE_WEP40:
65 case WLAN_CIPHER_SUITE_WEP104:
66 arg.key_cipher = WMI_CIPHER_WEP;
67 /* AP/IBSS mode requires self-key to be groupwise
68 * Otherwise pairwise key must be set */
69 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
70 arg.key_flags = WMI_KEY_PAIRWISE;
71 break;
72 default:
73 ath10k_warn("cipher %d is not supported\n", key->cipher);
74 return -EOPNOTSUPP;
75 }
76
77 if (cmd == DISABLE_KEY) {
78 arg.key_cipher = WMI_CIPHER_NONE;
79 arg.key_data = NULL;
80 }
81
82 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
83}
84
85static int ath10k_install_key(struct ath10k_vif *arvif,
86 struct ieee80211_key_conf *key,
87 enum set_key_cmd cmd,
88 const u8 *macaddr)
89{
90 struct ath10k *ar = arvif->ar;
91 int ret;
92
548db54c
MK		 93 lockdep_assert_held(&ar->conf_mutex);
94
5e3dd157
KV		 95 INIT_COMPLETION(ar->install_key_done);
96
97 ret = ath10k_send_key(arvif, key, cmd, macaddr);
98 if (ret)
99 return ret;
100
101 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
102 if (ret == 0)
103 return -ETIMEDOUT;
104
105 return 0;
106}
107
108static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
109 const u8 *addr)
110{
111 struct ath10k *ar = arvif->ar;
112 struct ath10k_peer *peer;
113 int ret;
114 int i;
115
116 lockdep_assert_held(&ar->conf_mutex);
117
118 spin_lock_bh(&ar->data_lock);
119 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
120 spin_unlock_bh(&ar->data_lock);
121
122 if (!peer)
123 return -ENOENT;
124
125 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
126 if (arvif->wep_keys[i] == NULL)
127 continue;
128
129 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
130 addr);
131 if (ret)
132 return ret;
133
134 peer->keys[i] = arvif->wep_keys[i];
135 }
136
137 return 0;
138}
139
140static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
141 const u8 *addr)
142{
143 struct ath10k *ar = arvif->ar;
144 struct ath10k_peer *peer;
145 int first_errno = 0;
146 int ret;
147 int i;
148
149 lockdep_assert_held(&ar->conf_mutex);
150
151 spin_lock_bh(&ar->data_lock);
152 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
153 spin_unlock_bh(&ar->data_lock);
154
155 if (!peer)
156 return -ENOENT;
157
158 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
159 if (peer->keys[i] == NULL)
160 continue;
161
162 ret = ath10k_install_key(arvif, peer->keys[i],
163 DISABLE_KEY, addr);
164 if (ret && first_errno == 0)
165 first_errno = ret;
166
167 if (ret)
168 ath10k_warn("could not remove peer wep key %d (%d)\n",
169 i, ret);
170
171 peer->keys[i] = NULL;
172 }
173
174 return first_errno;
175}
176
177static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
178 struct ieee80211_key_conf *key)
179{
180 struct ath10k *ar = arvif->ar;
181 struct ath10k_peer *peer;
182 u8 addr[ETH_ALEN];
183 int first_errno = 0;
184 int ret;
185 int i;
186
187 lockdep_assert_held(&ar->conf_mutex);
188
189 for (;;) {
190 /* since ath10k_install_key we can't hold data_lock all the
191 * time, so we try to remove the keys incrementally */
192 spin_lock_bh(&ar->data_lock);
193 i = 0;
194 list_for_each_entry(peer, &ar->peers, list) {
195 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
196 if (peer->keys[i] == key) {
197 memcpy(addr, peer->addr, ETH_ALEN);
198 peer->keys[i] = NULL;
199 break;
200 }
201 }
202
203 if (i < ARRAY_SIZE(peer->keys))
204 break;
205 }
206 spin_unlock_bh(&ar->data_lock);
207
208 if (i == ARRAY_SIZE(peer->keys))
209 break;
210
211 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
212 if (ret && first_errno == 0)
213 first_errno = ret;
214
215 if (ret)
216 ath10k_warn("could not remove key for %pM\n", addr);
217 }
218
219 return first_errno;
220}
221
222
223/*********************/
224/* General utilities */
225/*********************/
226
227static inline enum wmi_phy_mode
228chan_to_phymode(const struct cfg80211_chan_def *chandef)
229{
230 enum wmi_phy_mode phymode = MODE_UNKNOWN;
231
232 switch (chandef->chan->band) {
233 case IEEE80211_BAND_2GHZ:
234 switch (chandef->width) {
235 case NL80211_CHAN_WIDTH_20_NOHT:
236 phymode = MODE_11G;
237 break;
238 case NL80211_CHAN_WIDTH_20:
239 phymode = MODE_11NG_HT20;
240 break;
241 case NL80211_CHAN_WIDTH_40:
242 phymode = MODE_11NG_HT40;
243 break;
0f817ed5
JL		 244 case NL80211_CHAN_WIDTH_5:
245 case NL80211_CHAN_WIDTH_10:
5e3dd157
KV		 246 case NL80211_CHAN_WIDTH_80:
247 case NL80211_CHAN_WIDTH_80P80:
248 case NL80211_CHAN_WIDTH_160:
249 phymode = MODE_UNKNOWN;
250 break;
251 }
252 break;
253 case IEEE80211_BAND_5GHZ:
254 switch (chandef->width) {
255 case NL80211_CHAN_WIDTH_20_NOHT:
256 phymode = MODE_11A;
257 break;
258 case NL80211_CHAN_WIDTH_20:
259 phymode = MODE_11NA_HT20;
260 break;
261 case NL80211_CHAN_WIDTH_40:
262 phymode = MODE_11NA_HT40;
263 break;
264 case NL80211_CHAN_WIDTH_80:
265 phymode = MODE_11AC_VHT80;
266 break;
0f817ed5
JL		 267 case NL80211_CHAN_WIDTH_5:
268 case NL80211_CHAN_WIDTH_10:
5e3dd157
KV		 269 case NL80211_CHAN_WIDTH_80P80:
270 case NL80211_CHAN_WIDTH_160:
271 phymode = MODE_UNKNOWN;
272 break;
273 }
274 break;
275 default:
276 break;
277 }
278
279 WARN_ON(phymode == MODE_UNKNOWN);
280 return phymode;
281}
282
283static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
284{
285/*
286 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
287 * 0 for no restriction
288 * 1 for 1/4 us
289 * 2 for 1/2 us
290 * 3 for 1 us
291 * 4 for 2 us
292 * 5 for 4 us
293 * 6 for 8 us
294 * 7 for 16 us
295 */
296 switch (mpdudensity) {
297 case 0:
298 return 0;
299 case 1:
300 case 2:
301 case 3:
302 /* Our lower layer calculations limit our precision to
303 1 microsecond */
304 return 1;
305 case 4:
306 return 2;
307 case 5:
308 return 4;
309 case 6:
310 return 8;
311 case 7:
312 return 16;
313 default:
314 return 0;
315 }
316}
317
318static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
319{
320 int ret;
321
322 lockdep_assert_held(&ar->conf_mutex);
323
324 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
325 if (ret)
326 return ret;
327
328 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
329 if (ret)
330 return ret;
331
332 return 0;
333}
334
424121c3
MK		 335static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
336{
337 if (value != 0xFFFFFFFF)
338 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
339 ATH10K_RTS_MAX);
340
341 return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
342 WMI_VDEV_PARAM_RTS_THRESHOLD,
343 value);
344}
345
346static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
347{
348 if (value != 0xFFFFFFFF)
349 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
350 ATH10K_FRAGMT_THRESHOLD_MIN,
351 ATH10K_FRAGMT_THRESHOLD_MAX);
352
353 return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
354 WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
355 value);
356}
357
5e3dd157
KV		 358static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
359{
360 int ret;
361
362 lockdep_assert_held(&ar->conf_mutex);
363
364 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
365 if (ret)
366 return ret;
367
368 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
369 if (ret)
370 return ret;
371
372 return 0;
373}
374
375static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
376{
377 struct ath10k_peer *peer, *tmp;
378
379 lockdep_assert_held(&ar->conf_mutex);
380
381 spin_lock_bh(&ar->data_lock);
382 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
383 if (peer->vdev_id != vdev_id)
384 continue;
385
386 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
387 peer->addr, vdev_id);
388
389 list_del(&peer->list);
390 kfree(peer);
391 }
392 spin_unlock_bh(&ar->data_lock);
393}
394
a96d7745
MK		 395static void ath10k_peer_cleanup_all(struct ath10k *ar)
396{
397 struct ath10k_peer *peer, *tmp;
398
399 lockdep_assert_held(&ar->conf_mutex);
400
401 spin_lock_bh(&ar->data_lock);
402 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
403 list_del(&peer->list);
404 kfree(peer);
405 }
406 spin_unlock_bh(&ar->data_lock);
407}
408
5e3dd157
KV		 409/************************/
410/* Interface management */
411/************************/
412
413static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
414{
415 int ret;
416
548db54c
MK		 417 lockdep_assert_held(&ar->conf_mutex);
418
5e3dd157
KV		 419 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
420 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
421 if (ret == 0)
422 return -ETIMEDOUT;
423
424 return 0;
425}
426
427static int ath10k_vdev_start(struct ath10k_vif *arvif)
428{
429 struct ath10k *ar = arvif->ar;
430 struct ieee80211_conf *conf = &ar->hw->conf;
431 struct ieee80211_channel *channel = conf->chandef.chan;
432 struct wmi_vdev_start_request_arg arg = {};
433 int ret = 0;
434
435 lockdep_assert_held(&ar->conf_mutex);
436
437 INIT_COMPLETION(ar->vdev_setup_done);
438
439 arg.vdev_id = arvif->vdev_id;
440 arg.dtim_period = arvif->dtim_period;
441 arg.bcn_intval = arvif->beacon_interval;
442
443 arg.channel.freq = channel->center_freq;
444
445 arg.channel.band_center_freq1 = conf->chandef.center_freq1;
446
447 arg.channel.mode = chan_to_phymode(&conf->chandef);
448
449 arg.channel.min_power = channel->max_power * 3;
450 arg.channel.max_power = channel->max_power * 4;
451 arg.channel.max_reg_power = channel->max_reg_power * 4;
452 arg.channel.max_antenna_gain = channel->max_antenna_gain;
453
454 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
455 arg.ssid = arvif->u.ap.ssid;
456 arg.ssid_len = arvif->u.ap.ssid_len;
457 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
458 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
459 arg.ssid = arvif->vif->bss_conf.ssid;
460 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
461 }
462
463 ret = ath10k_wmi_vdev_start(ar, &arg);
464 if (ret) {
465 ath10k_warn("WMI vdev start failed: ret %d\n", ret);
466 return ret;
467 }
468
469 ret = ath10k_vdev_setup_sync(ar);
470 if (ret) {
471 ath10k_warn("vdev setup failed %d\n", ret);
472 return ret;
473 }
474
475 return ret;
476}
477
478static int ath10k_vdev_stop(struct ath10k_vif *arvif)
479{
480 struct ath10k *ar = arvif->ar;
481 int ret;
482
483 lockdep_assert_held(&ar->conf_mutex);
484
485 INIT_COMPLETION(ar->vdev_setup_done);
486
487 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
488 if (ret) {
489 ath10k_warn("WMI vdev stop failed: ret %d\n", ret);
490 return ret;
491 }
492
493 ret = ath10k_vdev_setup_sync(ar);
494 if (ret) {
495 ath10k_warn("vdev setup failed %d\n", ret);
496 return ret;
497 }
498
499 return ret;
500}
501
502static int ath10k_monitor_start(struct ath10k *ar, int vdev_id)
503{
504 struct ieee80211_channel *channel = ar->hw->conf.chandef.chan;
505 struct wmi_vdev_start_request_arg arg = {};
506 enum nl80211_channel_type type;
507 int ret = 0;
508
509 lockdep_assert_held(&ar->conf_mutex);
510
511 type = cfg80211_get_chandef_type(&ar->hw->conf.chandef);
512
513 arg.vdev_id = vdev_id;
514 arg.channel.freq = channel->center_freq;
515 arg.channel.band_center_freq1 = ar->hw->conf.chandef.center_freq1;
516
517 /* TODO setup this dynamically, what in case we
518 don't have any vifs? */
519 arg.channel.mode = chan_to_phymode(&ar->hw->conf.chandef);
520
521 arg.channel.min_power = channel->max_power * 3;
522 arg.channel.max_power = channel->max_power * 4;
523 arg.channel.max_reg_power = channel->max_reg_power * 4;
524 arg.channel.max_antenna_gain = channel->max_antenna_gain;
525
526 ret = ath10k_wmi_vdev_start(ar, &arg);
527 if (ret) {
528 ath10k_warn("Monitor vdev start failed: ret %d\n", ret);
529 return ret;
530 }
531
532 ret = ath10k_vdev_setup_sync(ar);
533 if (ret) {
534 ath10k_warn("Monitor vdev setup failed %d\n", ret);
535 return ret;
536 }
537
538 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
539 if (ret) {
540 ath10k_warn("Monitor vdev up failed: %d\n", ret);
541 goto vdev_stop;
542 }
543
544 ar->monitor_vdev_id = vdev_id;
545 ar->monitor_enabled = true;
546
547 return 0;
548
549vdev_stop:
550 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
551 if (ret)
552 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
553
554 return ret;
555}
556
557static int ath10k_monitor_stop(struct ath10k *ar)
558{
559 int ret = 0;
560
561 lockdep_assert_held(&ar->conf_mutex);
562
563 /* For some reasons, ath10k_wmi_vdev_down() here couse
564 * often ath10k_wmi_vdev_stop() to fail. Next we could
565 * not run monitor vdev and driver reload
566 * required. Don't see such problems we skip
567 * ath10k_wmi_vdev_down() here.
568 */
569
570 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
571 if (ret)
572 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
573
574 ret = ath10k_vdev_setup_sync(ar);
575 if (ret)
576 ath10k_warn("Monitor_down sync failed: %d\n", ret);
577
578 ar->monitor_enabled = false;
579 return ret;
580}
581
582static int ath10k_monitor_create(struct ath10k *ar)
583{
584 int bit, ret = 0;
585
586 lockdep_assert_held(&ar->conf_mutex);
587
588 if (ar->monitor_present) {
589 ath10k_warn("Monitor mode already enabled\n");
590 return 0;
591 }
592
593 bit = ffs(ar->free_vdev_map);
594 if (bit == 0) {
595 ath10k_warn("No free VDEV slots\n");
596 return -ENOMEM;
597 }
598
599 ar->monitor_vdev_id = bit - 1;
600 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
601
602 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
603 WMI_VDEV_TYPE_MONITOR,
604 0, ar->mac_addr);
605 if (ret) {
606 ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret);
607 goto vdev_fail;
608 }
609
610 ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface created, vdev id: %d\n",
611 ar->monitor_vdev_id);
612
613 ar->monitor_present = true;
614 return 0;
615
616vdev_fail:
617 /*
618 * Restore the ID to the global map.
619 */
620 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
621 return ret;
622}
623
624static int ath10k_monitor_destroy(struct ath10k *ar)
625{
626 int ret = 0;
627
628 lockdep_assert_held(&ar->conf_mutex);
629
630 if (!ar->monitor_present)
631 return 0;
632
633 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
634 if (ret) {
635 ath10k_warn("WMI vdev monitor delete failed: %d\n", ret);
636 return ret;
637 }
638
639 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
640 ar->monitor_present = false;
641
642 ath10k_dbg(ATH10K_DBG_MAC, "Monitor interface destroyed, vdev id: %d\n",
643 ar->monitor_vdev_id);
644 return ret;
645}
646
647static void ath10k_control_beaconing(struct ath10k_vif *arvif,
648 struct ieee80211_bss_conf *info)
649{
650 int ret = 0;
651
548db54c
MK		 652 lockdep_assert_held(&arvif->ar->conf_mutex);
653
5e3dd157
KV		 654 if (!info->enable_beacon) {
655 ath10k_vdev_stop(arvif);
656 return;
657 }
658
659 arvif->tx_seq_no = 0x1000;
660
661 ret = ath10k_vdev_start(arvif);
662 if (ret)
663 return;
664
665 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid);
666 if (ret) {
667 ath10k_warn("Failed to bring up VDEV: %d\n",
668 arvif->vdev_id);
669 return;
670 }
671 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d up\n", arvif->vdev_id);
672}
673
674static void ath10k_control_ibss(struct ath10k_vif *arvif,
675 struct ieee80211_bss_conf *info,
676 const u8 self_peer[ETH_ALEN])
677{
678 int ret = 0;
679
548db54c
MK		 680 lockdep_assert_held(&arvif->ar->conf_mutex);
681
5e3dd157
KV		 682 if (!info->ibss_joined) {
683 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
684 if (ret)
685 ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n",
686 self_peer, arvif->vdev_id, ret);
687
688 if (is_zero_ether_addr(arvif->u.ibss.bssid))
689 return;
690
691 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
692 arvif->u.ibss.bssid);
693 if (ret) {
694 ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n",
695 arvif->u.ibss.bssid, arvif->vdev_id, ret);
696 return;
697 }
698
699 memset(arvif->u.ibss.bssid, 0, ETH_ALEN);
700
701 return;
702 }
703
704 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
705 if (ret) {
706 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n",
707 self_peer, arvif->vdev_id, ret);
708 return;
709 }
710
711 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
712 WMI_VDEV_PARAM_ATIM_WINDOW,
713 ATH10K_DEFAULT_ATIM);
714 if (ret)
715 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n",
716 arvif->vdev_id, ret);
717}
718
719/*
720 * Review this when mac80211 gains per-interface powersave support.
721 */
722static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
723{
724 struct ath10k_generic_iter *ar_iter = data;
725 struct ieee80211_conf *conf = &ar_iter->ar->hw->conf;
726 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
727 enum wmi_sta_powersave_param param;
728 enum wmi_sta_ps_mode psmode;
729 int ret;
730
548db54c
MK		 731 lockdep_assert_held(&arvif->ar->conf_mutex);
732
5e3dd157
KV		 733 if (vif->type != NL80211_IFTYPE_STATION)
734 return;
735
736 if (conf->flags & IEEE80211_CONF_PS) {
737 psmode = WMI_STA_PS_MODE_ENABLED;
738 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
739
740 ret = ath10k_wmi_set_sta_ps_param(ar_iter->ar,
741 arvif->vdev_id,
742 param,
743 conf->dynamic_ps_timeout);
744 if (ret) {
745 ath10k_warn("Failed to set inactivity time for VDEV: %d\n",
746 arvif->vdev_id);
747 return;
748 }
749
750 ar_iter->ret = ret;
751 } else {
752 psmode = WMI_STA_PS_MODE_DISABLED;
753 }
754
755 ar_iter->ret = ath10k_wmi_set_psmode(ar_iter->ar, arvif->vdev_id,
756 psmode);
757 if (ar_iter->ret)
758 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
759 psmode, arvif->vdev_id);
760 else
761 ath10k_dbg(ATH10K_DBG_MAC, "Set PS Mode: %d for VDEV: %d\n",
762 psmode, arvif->vdev_id);
763}
764
765/**********************/
766/* Station management */
767/**********************/
768
769static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
770 struct ath10k_vif *arvif,
771 struct ieee80211_sta *sta,
772 struct ieee80211_bss_conf *bss_conf,
773 struct wmi_peer_assoc_complete_arg *arg)
774{
548db54c
MK		 775 lockdep_assert_held(&ar->conf_mutex);
776
5e3dd157
KV		 777 memcpy(arg->addr, sta->addr, ETH_ALEN);
778 arg->vdev_id = arvif->vdev_id;
779 arg->peer_aid = sta->aid;
780 arg->peer_flags |= WMI_PEER_AUTH;
781
782 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
783 /*
784 * Seems FW have problems with Power Save in STA
785 * mode when we setup this parameter to high (eg. 5).
786 * Often we see that FW don't send NULL (with clean P flags)
787 * frame even there is info about buffered frames in beacons.
788 * Sometimes we have to wait more than 10 seconds before FW
789 * will wakeup. Often sending one ping from AP to our device
790 * just fail (more than 50%).
791 *
792 * Seems setting this FW parameter to 1 couse FW
793 * will check every beacon and will wakup immediately
794 * after detection buffered data.
795 */
796 arg->peer_listen_intval = 1;
797 else
798 arg->peer_listen_intval = ar->hw->conf.listen_interval;
799
800 arg->peer_num_spatial_streams = 1;
801
802 /*
803 * The assoc capabilities are available only in managed mode.
804 */
805 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
806 arg->peer_caps = bss_conf->assoc_capability;
807}
808
809static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
810 struct ath10k_vif *arvif,
811 struct wmi_peer_assoc_complete_arg *arg)
812{
813 struct ieee80211_vif *vif = arvif->vif;
814 struct ieee80211_bss_conf *info = &vif->bss_conf;
815 struct cfg80211_bss *bss;
816 const u8 *rsnie = NULL;
817 const u8 *wpaie = NULL;
818
548db54c
MK		 819 lockdep_assert_held(&ar->conf_mutex);
820
5e3dd157
KV		 821 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
822 info->bssid, NULL, 0, 0, 0);
823 if (bss) {
824 const struct cfg80211_bss_ies *ies;
825
826 rcu_read_lock();
827 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
828
829 ies = rcu_dereference(bss->ies);
830
831 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
832 WLAN_OUI_TYPE_MICROSOFT_WPA,
833 ies->data,
834 ies->len);
835 rcu_read_unlock();
836 cfg80211_put_bss(ar->hw->wiphy, bss);
837 }
838
839 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
840 if (rsnie || wpaie) {
841 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
842 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
843 }
844
845 if (wpaie) {
846 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
847 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
848 }
849}
850
851static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
852 struct ieee80211_sta *sta,
853 struct wmi_peer_assoc_complete_arg *arg)
854{
855 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
856 const struct ieee80211_supported_band *sband;
857 const struct ieee80211_rate *rates;
858 u32 ratemask;
859 int i;
860
548db54c
MK		 861 lockdep_assert_held(&ar->conf_mutex);
862
5e3dd157
KV		 863 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
864 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
865 rates = sband->bitrates;
866
867 rateset->num_rates = 0;
868
869 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
870 if (!(ratemask & 1))
871 continue;
872
873 rateset->rates[rateset->num_rates] = rates->hw_value;
874 rateset->num_rates++;
875 }
876}
877
878static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
879 struct ieee80211_sta *sta,
880 struct wmi_peer_assoc_complete_arg *arg)
881{
882 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
883 int smps;
884 int i, n;
885
548db54c
MK		 886 lockdep_assert_held(&ar->conf_mutex);
887
5e3dd157
KV		 888 if (!ht_cap->ht_supported)
889 return;
890
891 arg->peer_flags |= WMI_PEER_HT;
892 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
893 ht_cap->ampdu_factor)) - 1;
894
895 arg->peer_mpdu_density =
896 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
897
898 arg->peer_ht_caps = ht_cap->cap;
899 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
900
901 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
902 arg->peer_flags |= WMI_PEER_LDPC;
903
904 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
905 arg->peer_flags |= WMI_PEER_40MHZ;
906 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
907 }
908
909 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
910 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
911
912 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
913 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
914
915 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
916 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
917 arg->peer_flags |= WMI_PEER_STBC;
918 }
919
920 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
921 u32 stbc;
922 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
923 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
924 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
925 arg->peer_rate_caps |= stbc;
926 arg->peer_flags |= WMI_PEER_STBC;
927 }
928
929 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
930 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
931
932 if (smps == WLAN_HT_CAP_SM_PS_STATIC) {
933 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
934 arg->peer_flags |= WMI_PEER_STATIC_MIMOPS;
935 } else if (smps == WLAN_HT_CAP_SM_PS_DYNAMIC) {
936 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
937 arg->peer_flags |= WMI_PEER_DYN_MIMOPS;
938 }
939
940 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
941 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
942 else if (ht_cap->mcs.rx_mask[1])
943 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
944
945 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
946 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
947 arg->peer_ht_rates.rates[n++] = i;
948
949 arg->peer_ht_rates.num_rates = n;
950 arg->peer_num_spatial_streams = max((n+7) / 8, 1);
951
952 ath10k_dbg(ATH10K_DBG_MAC, "mcs cnt %d nss %d\n",
953 arg->peer_ht_rates.num_rates,
954 arg->peer_num_spatial_streams);
955}
956
957static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar,
958 struct ath10k_vif *arvif,
959 struct ieee80211_sta *sta,
960 struct ieee80211_bss_conf *bss_conf,
961 struct wmi_peer_assoc_complete_arg *arg)
962{
963 u32 uapsd = 0;
964 u32 max_sp = 0;
965
548db54c
MK		 966 lockdep_assert_held(&ar->conf_mutex);
967
5e3dd157
KV		 968 if (sta->wme)
969 arg->peer_flags |= WMI_PEER_QOS;
970
971 if (sta->wme && sta->uapsd_queues) {
972 ath10k_dbg(ATH10K_DBG_MAC, "uapsd_queues: 0x%X, max_sp: %d\n",
973 sta->uapsd_queues, sta->max_sp);
974
975 arg->peer_flags |= WMI_PEER_APSD;
976 arg->peer_flags |= WMI_RC_UAPSD_FLAG;
977
978 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
979 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
980 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
981 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
982 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
983 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
984 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
985 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
986 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
987 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
988 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
989 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
990
991
992 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
993 max_sp = sta->max_sp;
994
995 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
996 sta->addr,
997 WMI_AP_PS_PEER_PARAM_UAPSD,
998 uapsd);
999
1000 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1001 sta->addr,
1002 WMI_AP_PS_PEER_PARAM_MAX_SP,
1003 max_sp);
1004
1005 /* TODO setup this based on STA listen interval and
1006 beacon interval. Currently we don't know
1007 sta->listen_interval - mac80211 patch required.
1008 Currently use 10 seconds */
1009 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1010 sta->addr,
1011 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1012 10);
1013 }
1014}
1015
1016static void ath10k_peer_assoc_h_qos_sta(struct ath10k *ar,
1017 struct ath10k_vif *arvif,
1018 struct ieee80211_sta *sta,
1019 struct ieee80211_bss_conf *bss_conf,
1020 struct wmi_peer_assoc_complete_arg *arg)
1021{
1022 if (bss_conf->qos)
1023 arg->peer_flags |= WMI_PEER_QOS;
1024}
1025
1026static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1027 struct ieee80211_sta *sta,
1028 struct wmi_peer_assoc_complete_arg *arg)
1029{
1030 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1031
1032 if (!vht_cap->vht_supported)
1033 return;
1034
1035 arg->peer_flags |= WMI_PEER_VHT;
1036
1037 arg->peer_vht_caps = vht_cap->cap;
1038
1039 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1040 arg->peer_flags |= WMI_PEER_80MHZ;
1041
1042 arg->peer_vht_rates.rx_max_rate =
1043 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1044 arg->peer_vht_rates.rx_mcs_set =
1045 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1046 arg->peer_vht_rates.tx_max_rate =
1047 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1048 arg->peer_vht_rates.tx_mcs_set =
1049 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1050
1051 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer\n");
1052}
1053
1054static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1055 struct ath10k_vif *arvif,
1056 struct ieee80211_sta *sta,
1057 struct ieee80211_bss_conf *bss_conf,
1058 struct wmi_peer_assoc_complete_arg *arg)
1059{
1060 switch (arvif->vdev_type) {
1061 case WMI_VDEV_TYPE_AP:
1062 ath10k_peer_assoc_h_qos_ap(ar, arvif, sta, bss_conf, arg);
1063 break;
1064 case WMI_VDEV_TYPE_STA:
1065 ath10k_peer_assoc_h_qos_sta(ar, arvif, sta, bss_conf, arg);
1066 break;
1067 default:
1068 break;
1069 }
1070}
1071
1072static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1073 struct ath10k_vif *arvif,
1074 struct ieee80211_sta *sta,
1075 struct wmi_peer_assoc_complete_arg *arg)
1076{
1077 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1078
1079 /* FIXME: add VHT */
1080
1081 switch (ar->hw->conf.chandef.chan->band) {
1082 case IEEE80211_BAND_2GHZ:
1083 if (sta->ht_cap.ht_supported) {
1084 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1085 phymode = MODE_11NG_HT40;
1086 else
1087 phymode = MODE_11NG_HT20;
1088 } else {
1089 phymode = MODE_11G;
1090 }
1091
1092 break;
1093 case IEEE80211_BAND_5GHZ:
1094 if (sta->ht_cap.ht_supported) {
1095 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1096 phymode = MODE_11NA_HT40;
1097 else
1098 phymode = MODE_11NA_HT20;
1099 } else {
1100 phymode = MODE_11A;
1101 }
1102
1103 break;
1104 default:
1105 break;
1106 }
1107
1108 arg->peer_phymode = phymode;
1109 WARN_ON(phymode == MODE_UNKNOWN);
1110}
1111
1112static int ath10k_peer_assoc(struct ath10k *ar,
1113 struct ath10k_vif *arvif,
1114 struct ieee80211_sta *sta,
1115 struct ieee80211_bss_conf *bss_conf)
1116{
1117 struct wmi_peer_assoc_complete_arg arg;
1118
548db54c
MK		 1119 lockdep_assert_held(&ar->conf_mutex);
1120
5e3dd157
KV		 1121 memset(&arg, 0, sizeof(struct wmi_peer_assoc_complete_arg));
1122
1123 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, &arg);
1124 ath10k_peer_assoc_h_crypto(ar, arvif, &arg);
1125 ath10k_peer_assoc_h_rates(ar, sta, &arg);
1126 ath10k_peer_assoc_h_ht(ar, sta, &arg);
1127 ath10k_peer_assoc_h_vht(ar, sta, &arg);
1128 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, &arg);
1129 ath10k_peer_assoc_h_phymode(ar, arvif, sta, &arg);
1130
1131 return ath10k_wmi_peer_assoc(ar, &arg);
1132}
1133
1134/* can be called only in mac80211 callbacks due to `key_count` usage */
1135static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1136 struct ieee80211_vif *vif,
1137 struct ieee80211_bss_conf *bss_conf)
1138{
1139 struct ath10k *ar = hw->priv;
1140 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1141 struct ieee80211_sta *ap_sta;
1142 int ret;
1143
548db54c
MK		 1144 lockdep_assert_held(&ar->conf_mutex);
1145
5e3dd157
KV		 1146 rcu_read_lock();
1147
1148 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1149 if (!ap_sta) {
1150 ath10k_warn("Failed to find station entry for %pM\n",
1151 bss_conf->bssid);
1152 rcu_read_unlock();
1153 return;
1154 }
1155
1156 ret = ath10k_peer_assoc(ar, arvif, ap_sta, bss_conf);
1157 if (ret) {
1158 ath10k_warn("Peer assoc failed for %pM\n", bss_conf->bssid);
1159 rcu_read_unlock();
1160 return;
1161 }
1162
1163 rcu_read_unlock();
1164
1165 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid,
1166 bss_conf->bssid);
1167 if (ret)
1168 ath10k_warn("VDEV: %d up failed: ret %d\n",
1169 arvif->vdev_id, ret);
1170 else
1171 ath10k_dbg(ATH10K_DBG_MAC,
1172 "VDEV: %d associated, BSSID: %pM, AID: %d\n",
1173 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1174}
1175
1176/*
1177 * FIXME: flush TIDs
1178 */
1179static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1180 struct ieee80211_vif *vif)
1181{
1182 struct ath10k *ar = hw->priv;
1183 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1184 int ret;
1185
548db54c
MK		 1186 lockdep_assert_held(&ar->conf_mutex);
1187
5e3dd157
KV		 1188 /*
1189 * For some reason, calling VDEV-DOWN before VDEV-STOP
1190 * makes the FW to send frames via HTT after disassociation.
1191 * No idea why this happens, even though VDEV-DOWN is supposed
1192 * to be analogous to link down, so just stop the VDEV.
1193 */
1194 ret = ath10k_vdev_stop(arvif);
1195 if (!ret)
1196 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d stopped\n",
1197 arvif->vdev_id);
1198
1199 /*
1200 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1201 * report beacons from previously associated network through HTT.
1202 * This in turn would spam mac80211 WARN_ON if we bring down all
1203 * interfaces as it expects there is no rx when no interface is
1204 * running.
1205 */
1206 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1207 if (ret)
1208 ath10k_dbg(ATH10K_DBG_MAC, "VDEV: %d ath10k_wmi_vdev_down failed (%d)\n",
1209 arvif->vdev_id, ret);
1210
1211 ath10k_wmi_flush_tx(ar);
1212
1213 arvif->def_wep_key_index = 0;
1214}
1215
1216static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1217 struct ieee80211_sta *sta)
1218{
1219 int ret = 0;
1220
548db54c
MK		 1221 lockdep_assert_held(&ar->conf_mutex);
1222
5e3dd157
KV		 1223 ret = ath10k_peer_assoc(ar, arvif, sta, NULL);
1224 if (ret) {
1225 ath10k_warn("WMI peer assoc failed for %pM\n", sta->addr);
1226 return ret;
1227 }
1228
1229 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1230 if (ret) {
1231 ath10k_warn("could not install peer wep keys (%d)\n", ret);
1232 return ret;
1233 }
1234
1235 return ret;
1236}
1237
1238static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1239 struct ieee80211_sta *sta)
1240{
1241 int ret = 0;
1242
548db54c
MK		 1243 lockdep_assert_held(&ar->conf_mutex);
1244
5e3dd157
KV		 1245 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1246 if (ret) {
1247 ath10k_warn("could not clear all peer wep keys (%d)\n", ret);
1248 return ret;
1249 }
1250
1251 return ret;
1252}
1253
1254/**************/
1255/* Regulatory */
1256/**************/
1257
1258static int ath10k_update_channel_list(struct ath10k *ar)
1259{
1260 struct ieee80211_hw *hw = ar->hw;
1261 struct ieee80211_supported_band **bands;
1262 enum ieee80211_band band;
1263 struct ieee80211_channel *channel;
1264 struct wmi_scan_chan_list_arg arg = {0};
1265 struct wmi_channel_arg *ch;
1266 bool passive;
1267 int len;
1268 int ret;
1269 int i;
1270
548db54c
MK		 1271 lockdep_assert_held(&ar->conf_mutex);
1272
5e3dd157
KV		 1273 bands = hw->wiphy->bands;
1274 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1275 if (!bands[band])
1276 continue;
1277
1278 for (i = 0; i < bands[band]->n_channels; i++) {
1279 if (bands[band]->channels[i].flags &
1280 IEEE80211_CHAN_DISABLED)
1281 continue;
1282
1283 arg.n_channels++;
1284 }
1285 }
1286
1287 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1288 arg.channels = kzalloc(len, GFP_KERNEL);
1289 if (!arg.channels)
1290 return -ENOMEM;
1291
1292 ch = arg.channels;
1293 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1294 if (!bands[band])
1295 continue;
1296
1297 for (i = 0; i < bands[band]->n_channels; i++) {
1298 channel = &bands[band]->channels[i];
1299
1300 if (channel->flags & IEEE80211_CHAN_DISABLED)
1301 continue;
1302
1303 ch->allow_ht = true;
1304
1305 /* FIXME: when should we really allow VHT? */
1306 ch->allow_vht = true;
1307
1308 ch->allow_ibss =
1309 !(channel->flags & IEEE80211_CHAN_NO_IBSS);
1310
1311 ch->ht40plus =
1312 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1313
1314 passive = channel->flags & IEEE80211_CHAN_PASSIVE_SCAN;
1315 ch->passive = passive;
1316
1317 ch->freq = channel->center_freq;
1318 ch->min_power = channel->max_power * 3;
1319 ch->max_power = channel->max_power * 4;
1320 ch->max_reg_power = channel->max_reg_power * 4;
1321 ch->max_antenna_gain = channel->max_antenna_gain;
1322 ch->reg_class_id = 0; /* FIXME */
1323
1324 /* FIXME: why use only legacy modes, why not any
1325 * HT/VHT modes? Would that even make any
1326 * difference? */
1327 if (channel->band == IEEE80211_BAND_2GHZ)
1328 ch->mode = MODE_11G;
1329 else
1330 ch->mode = MODE_11A;
1331
1332 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1333 continue;
1334
1335 ath10k_dbg(ATH10K_DBG_WMI,
1336 "%s: [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1337 __func__, ch - arg.channels, arg.n_channels,
1338 ch->freq, ch->max_power, ch->max_reg_power,
1339 ch->max_antenna_gain, ch->mode);
1340
1341 ch++;
1342 }
1343 }
1344
1345 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1346 kfree(arg.channels);
1347
1348 return ret;
1349}
1350
f7843d7f 1351static void ath10k_regd_update(struct ath10k *ar)
5e3dd157 1352{
5e3dd157 1353 struct reg_dmn_pair_mapping *regpair;
5e3dd157
KV		 1354 int ret;
1355
f7843d7f 1356 lockdep_assert_held(&ar->conf_mutex);
5e3dd157
KV		 1357
1358 ret = ath10k_update_channel_list(ar);
1359 if (ret)
1360 ath10k_warn("could not update channel list (%d)\n", ret);
1361
1362 regpair = ar->ath_common.regulatory.regpair;
f7843d7f 1363
5e3dd157
KV		 1364 /* Target allows setting up per-band regdomain but ath_common provides
1365 * a combined one only */
1366 ret = ath10k_wmi_pdev_set_regdomain(ar,
1367 regpair->regDmnEnum,
1368 regpair->regDmnEnum, /* 2ghz */
1369 regpair->regDmnEnum, /* 5ghz */
1370 regpair->reg_2ghz_ctl,
1371 regpair->reg_5ghz_ctl);
1372 if (ret)
1373 ath10k_warn("could not set pdev regdomain (%d)\n", ret);
f7843d7f 1374}
548db54c 1375
f7843d7f
MK		 1376static void ath10k_reg_notifier(struct wiphy *wiphy,
1377 struct regulatory_request *request)
1378{
1379 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1380 struct ath10k *ar = hw->priv;
1381
1382 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1383
1384 mutex_lock(&ar->conf_mutex);
1385 if (ar->state == ATH10K_STATE_ON)
1386 ath10k_regd_update(ar);
548db54c 1387 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 1388}
1389
1390/***************/
1391/* TX handlers */
1392/***************/
1393
1394/*
1395 * Frames sent to the FW have to be in "Native Wifi" format.
1396 * Strip the QoS field from the 802.11 header.
1397 */
1398static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1399 struct ieee80211_tx_control *control,
1400 struct sk_buff *skb)
1401{
1402 struct ieee80211_hdr *hdr = (void *)skb->data;
1403 u8 *qos_ctl;
1404
1405 if (!ieee80211_is_data_qos(hdr->frame_control))
1406 return;
1407
1408 qos_ctl = ieee80211_get_qos_ctl(hdr);
ba0ccd7a
MK		 1409 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1410 skb->data, (void *)qos_ctl - (void *)skb->data);
1411 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
5e3dd157
KV		 1412}
1413
1414static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1415{
1416 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1417 struct ieee80211_vif *vif = info->control.vif;
1418 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1419 struct ath10k *ar = arvif->ar;
1420 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1421 struct ieee80211_key_conf *key = info->control.hw_key;
1422 int ret;
1423
1424 /* TODO AP mode should be implemented */
1425 if (vif->type != NL80211_IFTYPE_STATION)
1426 return;
1427
1428 if (!ieee80211_has_protected(hdr->frame_control))
1429 return;
1430
1431 if (!key)
1432 return;
1433
1434 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1435 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1436 return;
1437
1438 if (key->keyidx == arvif->def_wep_key_index)
1439 return;
1440
1441 ath10k_dbg(ATH10K_DBG_MAC, "new wep keyidx will be %d\n", key->keyidx);
1442
1443 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1444 WMI_VDEV_PARAM_DEF_KEYID,
1445 key->keyidx);
1446 if (ret) {
1447 ath10k_warn("could not update wep keyidx (%d)\n", ret);
1448 return;
1449 }
1450
1451 arvif->def_wep_key_index = key->keyidx;
1452}
1453
1454static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1455{
1456 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1457 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1458 struct ieee80211_vif *vif = info->control.vif;
1459 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1460
1461 /* This is case only for P2P_GO */
1462 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1463 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1464 return;
1465
1466 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1467 spin_lock_bh(&ar->data_lock);
1468 if (arvif->u.ap.noa_data)
1469 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1470 GFP_ATOMIC))
1471 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1472 arvif->u.ap.noa_data,
1473 arvif->u.ap.noa_len);
1474 spin_unlock_bh(&ar->data_lock);
1475 }
1476}
1477
1478static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1479{
1480 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1481 int ret;
1482
1483 if (ieee80211_is_mgmt(hdr->frame_control))
edb8236d 1484 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
5e3dd157
KV		 1485 else if (ieee80211_is_nullfunc(hdr->frame_control))
1486 /* FW does not report tx status properly for NullFunc frames
1487 * unless they are sent through mgmt tx path. mac80211 sends
1488 * those frames when it detects link/beacon loss and depends on
1489 * the tx status to be correct. */
edb8236d 1490 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
5e3dd157 1491 else
edb8236d 1492 ret = ath10k_htt_tx(&ar->htt, skb);
5e3dd157
KV		 1493
1494 if (ret) {
1495 ath10k_warn("tx failed (%d). dropping packet.\n", ret);
1496 ieee80211_free_txskb(ar->hw, skb);
1497 }
1498}
1499
1500void ath10k_offchan_tx_purge(struct ath10k *ar)
1501{
1502 struct sk_buff *skb;
1503
1504 for (;;) {
1505 skb = skb_dequeue(&ar->offchan_tx_queue);
1506 if (!skb)
1507 break;
1508
1509 ieee80211_free_txskb(ar->hw, skb);
1510 }
1511}
1512
1513void ath10k_offchan_tx_work(struct work_struct *work)
1514{
1515 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
1516 struct ath10k_peer *peer;
1517 struct ieee80211_hdr *hdr;
1518 struct sk_buff *skb;
1519 const u8 *peer_addr;
1520 int vdev_id;
1521 int ret;
1522
1523 /* FW requirement: We must create a peer before FW will send out
1524 * an offchannel frame. Otherwise the frame will be stuck and
1525 * never transmitted. We delete the peer upon tx completion.
1526 * It is unlikely that a peer for offchannel tx will already be
1527 * present. However it may be in some rare cases so account for that.
1528 * Otherwise we might remove a legitimate peer and break stuff. */
1529
1530 for (;;) {
1531 skb = skb_dequeue(&ar->offchan_tx_queue);
1532 if (!skb)
1533 break;
1534
1535 mutex_lock(&ar->conf_mutex);
1536
1537 ath10k_dbg(ATH10K_DBG_MAC, "processing offchannel skb %p\n",
1538 skb);
1539
1540 hdr = (struct ieee80211_hdr *)skb->data;
1541 peer_addr = ieee80211_get_DA(hdr);
1542 vdev_id = ATH10K_SKB_CB(skb)->htt.vdev_id;
1543
1544 spin_lock_bh(&ar->data_lock);
1545 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
1546 spin_unlock_bh(&ar->data_lock);
1547
1548 if (peer)
1549 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
1550 peer_addr, vdev_id);
1551
1552 if (!peer) {
1553 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
1554 if (ret)
1555 ath10k_warn("peer %pM on vdev %d not created (%d)\n",
1556 peer_addr, vdev_id, ret);
1557 }
1558
1559 spin_lock_bh(&ar->data_lock);
1560 INIT_COMPLETION(ar->offchan_tx_completed);
1561 ar->offchan_tx_skb = skb;
1562 spin_unlock_bh(&ar->data_lock);
1563
1564 ath10k_tx_htt(ar, skb);
1565
1566 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
1567 3 * HZ);
1568 if (ret <= 0)
1569 ath10k_warn("timed out waiting for offchannel skb %p\n",
1570 skb);
1571
1572 if (!peer) {
1573 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
1574 if (ret)
1575 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n",
1576 peer_addr, vdev_id, ret);
1577 }
1578
1579 mutex_unlock(&ar->conf_mutex);
1580 }
1581}
1582
1583/************/
1584/* Scanning */
1585/************/
1586
1587/*
1588 * This gets called if we dont get a heart-beat during scan.
1589 * This may indicate the FW has hung and we need to abort the
1590 * scan manually to prevent cancel_hw_scan() from deadlocking
1591 */
1592void ath10k_reset_scan(unsigned long ptr)
1593{
1594 struct ath10k *ar = (struct ath10k *)ptr;
1595
1596 spin_lock_bh(&ar->data_lock);
1597 if (!ar->scan.in_progress) {
1598 spin_unlock_bh(&ar->data_lock);
1599 return;
1600 }
1601
1602 ath10k_warn("scan timeout. resetting. fw issue?\n");
1603
1604 if (ar->scan.is_roc)
1605 ieee80211_remain_on_channel_expired(ar->hw);
1606 else
1607 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
1608
1609 ar->scan.in_progress = false;
1610 complete_all(&ar->scan.completed);
1611 spin_unlock_bh(&ar->data_lock);
1612}
1613
1614static int ath10k_abort_scan(struct ath10k *ar)
1615{
1616 struct wmi_stop_scan_arg arg = {
1617 .req_id = 1, /* FIXME */
1618 .req_type = WMI_SCAN_STOP_ONE,
1619 .u.scan_id = ATH10K_SCAN_ID,
1620 };
1621 int ret;
1622
1623 lockdep_assert_held(&ar->conf_mutex);
1624
1625 del_timer_sync(&ar->scan.timeout);
1626
1627 spin_lock_bh(&ar->data_lock);
1628 if (!ar->scan.in_progress) {
1629 spin_unlock_bh(&ar->data_lock);
1630 return 0;
1631 }
1632
1633 ar->scan.aborting = true;
1634 spin_unlock_bh(&ar->data_lock);
1635
1636 ret = ath10k_wmi_stop_scan(ar, &arg);
1637 if (ret) {
1638 ath10k_warn("could not submit wmi stop scan (%d)\n", ret);
adb8c9b7
MK		 1639 spin_lock_bh(&ar->data_lock);
1640 ar->scan.in_progress = false;
1641 ath10k_offchan_tx_purge(ar);
1642 spin_unlock_bh(&ar->data_lock);
5e3dd157
KV		 1643 return -EIO;
1644 }
1645
1646 ath10k_wmi_flush_tx(ar);
1647
1648 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
1649 if (ret == 0)
1650 ath10k_warn("timed out while waiting for scan to stop\n");
1651
1652 /* scan completion may be done right after we timeout here, so let's
1653 * check the in_progress and tell mac80211 scan is completed. if we
1654 * don't do that and FW fails to send us scan completion indication
1655 * then userspace won't be able to scan anymore */
1656 ret = 0;
1657
1658 spin_lock_bh(&ar->data_lock);
1659 if (ar->scan.in_progress) {
1660 ath10k_warn("could not stop scan. its still in progress\n");
1661 ar->scan.in_progress = false;
1662 ath10k_offchan_tx_purge(ar);
1663 ret = -ETIMEDOUT;
1664 }
1665 spin_unlock_bh(&ar->data_lock);
1666
1667 return ret;
1668}
1669
1670static int ath10k_start_scan(struct ath10k *ar,
1671 const struct wmi_start_scan_arg *arg)
1672{
1673 int ret;
1674
1675 lockdep_assert_held(&ar->conf_mutex);
1676
1677 ret = ath10k_wmi_start_scan(ar, arg);
1678 if (ret)
1679 return ret;
1680
1681 /* make sure we submit the command so the completion
1682 * timeout makes sense */
1683 ath10k_wmi_flush_tx(ar);
1684
1685 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
1686 if (ret == 0) {
1687 ath10k_abort_scan(ar);
1688 return ret;
1689 }
1690
1691 /* the scan can complete earlier, before we even
1692 * start the timer. in that case the timer handler
1693 * checks ar->scan.in_progress and bails out if its
1694 * false. Add a 200ms margin to account event/command
1695 * processing. */
1696 mod_timer(&ar->scan.timeout, jiffies +
1697 msecs_to_jiffies(arg->max_scan_time+200));
1698 return 0;
1699}
1700
1701/**********************/
1702/* mac80211 callbacks */
1703/**********************/
1704
1705static void ath10k_tx(struct ieee80211_hw *hw,
1706 struct ieee80211_tx_control *control,
1707 struct sk_buff *skb)
1708{
1709 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1710 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1711 struct ath10k *ar = hw->priv;
1712 struct ath10k_vif *arvif = NULL;
1713 u32 vdev_id = 0;
1714 u8 tid;
1715
1716 if (info->control.vif) {
1717 arvif = ath10k_vif_to_arvif(info->control.vif);
1718 vdev_id = arvif->vdev_id;
1719 } else if (ar->monitor_enabled) {
1720 vdev_id = ar->monitor_vdev_id;
1721 }
1722
1723 /* We should disable CCK RATE due to P2P */
1724 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
1725 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
1726
1727 /* we must calculate tid before we apply qos workaround
1728 * as we'd lose the qos control field */
1729 tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1730 if (ieee80211_is_data_qos(hdr->frame_control) &&
1731 is_unicast_ether_addr(ieee80211_get_DA(hdr))) {
1732 u8 *qc = ieee80211_get_qos_ctl(hdr);
1733 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
1734 }
1735
cf84bd4d
MK		 1736 /* it makes no sense to process injected frames like that */
1737 if (info->control.vif &&
1738 info->control.vif->type != NL80211_IFTYPE_MONITOR) {
1739 ath10k_tx_h_qos_workaround(hw, control, skb);
1740 ath10k_tx_h_update_wep_key(skb);
1741 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
1742 ath10k_tx_h_seq_no(skb);
1743 }
5e3dd157
KV		 1744
1745 memset(ATH10K_SKB_CB(skb), 0, sizeof(*ATH10K_SKB_CB(skb)));
1746 ATH10K_SKB_CB(skb)->htt.vdev_id = vdev_id;
1747 ATH10K_SKB_CB(skb)->htt.tid = tid;
1748
1749 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
1750 spin_lock_bh(&ar->data_lock);
1751 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
1752 ATH10K_SKB_CB(skb)->htt.vdev_id = ar->scan.vdev_id;
1753 spin_unlock_bh(&ar->data_lock);
1754
1755 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
1756
1757 skb_queue_tail(&ar->offchan_tx_queue, skb);
1758 ieee80211_queue_work(hw, &ar->offchan_tx_work);
1759 return;
1760 }
1761
1762 ath10k_tx_htt(ar, skb);
1763}
1764
1765/*
1766 * Initialize various parameters with default vaules.
1767 */
affd3217 1768void ath10k_halt(struct ath10k *ar)
818bdd16
MK		 1769{
1770 lockdep_assert_held(&ar->conf_mutex);
1771
1772 del_timer_sync(&ar->scan.timeout);
1773 ath10k_offchan_tx_purge(ar);
1774 ath10k_peer_cleanup_all(ar);
1775 ath10k_core_stop(ar);
1776 ath10k_hif_power_down(ar);
1777
1778 spin_lock_bh(&ar->data_lock);
1779 if (ar->scan.in_progress) {
1780 del_timer(&ar->scan.timeout);
1781 ar->scan.in_progress = false;
1782 ieee80211_scan_completed(ar->hw, true);
1783 }
1784 spin_unlock_bh(&ar->data_lock);
1785}
1786
5e3dd157
KV		 1787static int ath10k_start(struct ieee80211_hw *hw)
1788{
1789 struct ath10k *ar = hw->priv;
818bdd16 1790 int ret = 0;
5e3dd157 1791
548db54c
MK		 1792 mutex_lock(&ar->conf_mutex);
1793
affd3217
MK		 1794 if (ar->state != ATH10K_STATE_OFF &&
1795 ar->state != ATH10K_STATE_RESTARTING) {
818bdd16
MK		 1796 ret = -EINVAL;
1797 goto exit;
1798 }
1799
1800 ret = ath10k_hif_power_up(ar);
1801 if (ret) {
1802 ath10k_err("could not init hif (%d)\n", ret);
1803 ar->state = ATH10K_STATE_OFF;
1804 goto exit;
1805 }
1806
1807 ret = ath10k_core_start(ar);
1808 if (ret) {
1809 ath10k_err("could not init core (%d)\n", ret);
1810 ath10k_hif_power_down(ar);
1811 ar->state = ATH10K_STATE_OFF;
1812 goto exit;
1813 }
1814
affd3217
MK		 1815 if (ar->state == ATH10K_STATE_OFF)
1816 ar->state = ATH10K_STATE_ON;
1817 else if (ar->state == ATH10K_STATE_RESTARTING)
1818 ar->state = ATH10K_STATE_RESTARTED;
1819
5e3dd157
KV		 1820 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 1);
1821 if (ret)
1822 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n",
1823 ret);
1824
1825 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 0);
1826 if (ret)
1827 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n",
1828 ret);
1829
f7843d7f
MK		 1830 ath10k_regd_update(ar);
1831
818bdd16 1832exit:
548db54c 1833 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 1834 return 0;
1835}
1836
1837static void ath10k_stop(struct ieee80211_hw *hw)
1838{
1839 struct ath10k *ar = hw->priv;
1840
548db54c 1841 mutex_lock(&ar->conf_mutex);
affd3217
MK		 1842 if (ar->state == ATH10K_STATE_ON ||
1843 ar->state == ATH10K_STATE_RESTARTED ||
1844 ar->state == ATH10K_STATE_WEDGED)
818bdd16 1845 ath10k_halt(ar);
a96d7745 1846
f7843d7f 1847 ar->state = ATH10K_STATE_OFF;
548db54c
MK		 1848 mutex_unlock(&ar->conf_mutex);
1849
1850 cancel_work_sync(&ar->offchan_tx_work);
affd3217 1851 cancel_work_sync(&ar->restart_work);
5e3dd157
KV		 1852}
1853
affd3217 1854static void ath10k_config_ps(struct ath10k *ar)
5e3dd157
KV		 1855{
1856 struct ath10k_generic_iter ar_iter;
affd3217
MK		 1857
1858 lockdep_assert_held(&ar->conf_mutex);
1859
1860 /* During HW reconfiguration mac80211 reports all interfaces that were
1861 * running until reconfiguration was started. Since FW doesn't have any
1862 * vdevs at this point we must not iterate over this interface list.
1863 * This setting will be updated upon add_interface(). */
1864 if (ar->state == ATH10K_STATE_RESTARTED)
1865 return;
1866
1867 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
1868 ar_iter.ar = ar;
1869
1870 ieee80211_iterate_active_interfaces_atomic(
1871 ar->hw, IEEE80211_IFACE_ITER_NORMAL,
1872 ath10k_ps_iter, &ar_iter);
1873
1874 if (ar_iter.ret)
1875 ath10k_warn("failed to set ps config (%d)\n", ar_iter.ret);
1876}
1877
1878static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
1879{
5e3dd157
KV		 1880 struct ath10k *ar = hw->priv;
1881 struct ieee80211_conf *conf = &hw->conf;
1882 int ret = 0;
5e3dd157
KV		 1883
1884 mutex_lock(&ar->conf_mutex);
1885
1886 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1887 ath10k_dbg(ATH10K_DBG_MAC, "Config channel %d mhz\n",
1888 conf->chandef.chan->center_freq);
1889 spin_lock_bh(&ar->data_lock);
1890 ar->rx_channel = conf->chandef.chan;
1891 spin_unlock_bh(&ar->data_lock);
1892 }
1893
affd3217
MK		 1894 if (changed & IEEE80211_CONF_CHANGE_PS)
1895 ath10k_config_ps(ar);
5e3dd157
KV		 1896
1897 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1898 if (conf->flags & IEEE80211_CONF_MONITOR)
1899 ret = ath10k_monitor_create(ar);
1900 else
1901 ret = ath10k_monitor_destroy(ar);
1902 }
1903
affd3217 1904 ath10k_wmi_flush_tx(ar);
5e3dd157
KV		 1905 mutex_unlock(&ar->conf_mutex);
1906 return ret;
1907}
1908
1909/*
1910 * TODO:
1911 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
1912 * because we will send mgmt frames without CCK. This requirement
1913 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
1914 * in the TX packet.
1915 */
1916static int ath10k_add_interface(struct ieee80211_hw *hw,
1917 struct ieee80211_vif *vif)
1918{
1919 struct ath10k *ar = hw->priv;
1920 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1921 enum wmi_sta_powersave_param param;
1922 int ret = 0;
424121c3 1923 u32 value;
5e3dd157
KV		 1924 int bit;
1925
1926 mutex_lock(&ar->conf_mutex);
1927
1928 arvif->ar = ar;
1929 arvif->vif = vif;
1930
1931 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
1932 ath10k_warn("Only one monitor interface allowed\n");
1933 ret = -EBUSY;
1934 goto exit;
1935 }
1936
1937 bit = ffs(ar->free_vdev_map);
1938 if (bit == 0) {
1939 ret = -EBUSY;
1940 goto exit;
1941 }
1942
1943 arvif->vdev_id = bit - 1;
1944 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
1945 ar->free_vdev_map &= ~(1 << arvif->vdev_id);
1946
1947 if (ar->p2p)
1948 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
1949
1950 switch (vif->type) {
1951 case NL80211_IFTYPE_UNSPECIFIED:
1952 case NL80211_IFTYPE_STATION:
1953 arvif->vdev_type = WMI_VDEV_TYPE_STA;
1954 if (vif->p2p)
1955 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
1956 break;
1957 case NL80211_IFTYPE_ADHOC:
1958 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
1959 break;
1960 case NL80211_IFTYPE_AP:
1961 arvif->vdev_type = WMI_VDEV_TYPE_AP;
1962
1963 if (vif->p2p)
1964 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
1965 break;
1966 case NL80211_IFTYPE_MONITOR:
1967 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
1968 break;
1969 default:
1970 WARN_ON(1);
1971 break;
1972 }
1973
1974 ath10k_dbg(ATH10K_DBG_MAC, "Add interface: id %d type %d subtype %d\n",
1975 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
1976
1977 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
1978 arvif->vdev_subtype, vif->addr);
1979 if (ret) {
1980 ath10k_warn("WMI vdev create failed: ret %d\n", ret);
1981 goto exit;
1982 }
1983
1984 ret = ath10k_wmi_vdev_set_param(ar, 0, WMI_VDEV_PARAM_DEF_KEYID,
1985 arvif->def_wep_key_index);
1986 if (ret)
1987 ath10k_warn("Failed to set default keyid: %d\n", ret);
1988
1989 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1990 WMI_VDEV_PARAM_TX_ENCAP_TYPE,
1991 ATH10K_HW_TXRX_NATIVE_WIFI);
1992 if (ret)
1993 ath10k_warn("Failed to set TX encap: %d\n", ret);
1994
1995 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1996 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
1997 if (ret) {
1998 ath10k_warn("Failed to create peer for AP: %d\n", ret);
1999 goto exit;
2000 }
2001 }
2002
2003 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2004 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2005 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2006 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2007 param, value);
2008 if (ret)
2009 ath10k_warn("Failed to set RX wake policy: %d\n", ret);
2010
2011 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2012 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2013 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2014 param, value);
2015 if (ret)
2016 ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
2017
2018 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2019 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2020 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2021 param, value);
2022 if (ret)
2023 ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
2024 }
2025
424121c3 2026 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
679c54a6
MK		 2027 if (ret)
2028 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n",
2029 arvif->vdev_id, ret);
2030
424121c3 2031 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
679c54a6
MK		 2032 if (ret)
2033 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n",
2034 arvif->vdev_id, ret);
2035
5e3dd157
KV		 2036 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2037 ar->monitor_present = true;
2038
2039exit:
2040 mutex_unlock(&ar->conf_mutex);
2041 return ret;
2042}
2043
2044static void ath10k_remove_interface(struct ieee80211_hw *hw,
2045 struct ieee80211_vif *vif)
2046{
2047 struct ath10k *ar = hw->priv;
2048 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2049 int ret;
2050
2051 mutex_lock(&ar->conf_mutex);
2052
2053 ath10k_dbg(ATH10K_DBG_MAC, "Remove interface: id %d\n", arvif->vdev_id);
2054
2055 ar->free_vdev_map |= 1 << (arvif->vdev_id);
2056
2057 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2058 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2059 if (ret)
2060 ath10k_warn("Failed to remove peer for AP: %d\n", ret);
2061
2062 kfree(arvif->u.ap.noa_data);
2063 }
2064
2065 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2066 if (ret)
2067 ath10k_warn("WMI vdev delete failed: %d\n", ret);
2068
2069 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2070 ar->monitor_present = false;
2071
2072 ath10k_peer_cleanup(ar, arvif->vdev_id);
2073
2074 mutex_unlock(&ar->conf_mutex);
2075}
2076
2077/*
2078 * FIXME: Has to be verified.
2079 */
2080#define SUPPORTED_FILTERS \
2081 (FIF_PROMISC_IN_BSS | \
2082 FIF_ALLMULTI | \
2083 FIF_CONTROL | \
2084 FIF_PSPOLL | \
2085 FIF_OTHER_BSS | \
2086 FIF_BCN_PRBRESP_PROMISC | \
2087 FIF_PROBE_REQ | \
2088 FIF_FCSFAIL)
2089
2090static void ath10k_configure_filter(struct ieee80211_hw *hw,
2091 unsigned int changed_flags,
2092 unsigned int *total_flags,
2093 u64 multicast)
2094{
2095 struct ath10k *ar = hw->priv;
2096 int ret;
2097
2098 mutex_lock(&ar->conf_mutex);
2099
2100 changed_flags &= SUPPORTED_FILTERS;
2101 *total_flags &= SUPPORTED_FILTERS;
2102 ar->filter_flags = *total_flags;
2103
2104 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2105 !ar->monitor_enabled) {
2106 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
2107 if (ret)
2108 ath10k_warn("Unable to start monitor mode\n");
2109 else
2110 ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode started\n");
2111 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2112 ar->monitor_enabled) {
2113 ret = ath10k_monitor_stop(ar);
2114 if (ret)
2115 ath10k_warn("Unable to stop monitor mode\n");
2116 else
2117 ath10k_dbg(ATH10K_DBG_MAC, "Monitor mode stopped\n");
2118 }
2119
2120 mutex_unlock(&ar->conf_mutex);
2121}
2122
2123static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2124 struct ieee80211_vif *vif,
2125 struct ieee80211_bss_conf *info,
2126 u32 changed)
2127{
2128 struct ath10k *ar = hw->priv;
2129 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2130 int ret = 0;
2131
2132 mutex_lock(&ar->conf_mutex);
2133
2134 if (changed & BSS_CHANGED_IBSS)
2135 ath10k_control_ibss(arvif, info, vif->addr);
2136
2137 if (changed & BSS_CHANGED_BEACON_INT) {
2138 arvif->beacon_interval = info->beacon_int;
2139 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2140 WMI_VDEV_PARAM_BEACON_INTERVAL,
2141 arvif->beacon_interval);
2142 if (ret)
2143 ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
2144 arvif->vdev_id);
2145 else
2146 ath10k_dbg(ATH10K_DBG_MAC,
2147 "Beacon interval: %d set for VDEV: %d\n",
2148 arvif->beacon_interval, arvif->vdev_id);
2149 }
2150
2151 if (changed & BSS_CHANGED_BEACON) {
2152 ret = ath10k_wmi_pdev_set_param(ar,
2153 WMI_PDEV_PARAM_BEACON_TX_MODE,
2154 WMI_BEACON_STAGGERED_MODE);
2155 if (ret)
2156 ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
2157 arvif->vdev_id);
2158 else
2159 ath10k_dbg(ATH10K_DBG_MAC,
2160 "Set staggered beacon mode for VDEV: %d\n",
2161 arvif->vdev_id);
2162 }
2163
b70727e8 2164 if (changed & BSS_CHANGED_BEACON_INFO) {
5e3dd157
KV		 2165 arvif->dtim_period = info->dtim_period;
2166
2167 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2168 WMI_VDEV_PARAM_DTIM_PERIOD,
2169 arvif->dtim_period);
2170 if (ret)
2171 ath10k_warn("Failed to set dtim period for VDEV: %d\n",
2172 arvif->vdev_id);
2173 else
2174 ath10k_dbg(ATH10K_DBG_MAC,
2175 "Set dtim period: %d for VDEV: %d\n",
2176 arvif->dtim_period, arvif->vdev_id);
2177 }
2178
2179 if (changed & BSS_CHANGED_SSID &&
2180 vif->type == NL80211_IFTYPE_AP) {
2181 arvif->u.ap.ssid_len = info->ssid_len;
2182 if (info->ssid_len)
2183 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
2184 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2185 }
2186
2187 if (changed & BSS_CHANGED_BSSID) {
2188 if (!is_zero_ether_addr(info->bssid)) {
2189 ret = ath10k_peer_create(ar, arvif->vdev_id,
2190 info->bssid);
2191 if (ret)
2192 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2193 info->bssid, arvif->vdev_id);
2194 else
2195 ath10k_dbg(ATH10K_DBG_MAC,
2196 "Added peer: %pM for VDEV: %d\n",
2197 info->bssid, arvif->vdev_id);
2198
2199
2200 if (vif->type == NL80211_IFTYPE_STATION) {
2201 /*
2202 * this is never erased as we it for crypto key
2203 * clearing; this is FW requirement
2204 */
2205 memcpy(arvif->u.sta.bssid, info->bssid,
2206 ETH_ALEN);
2207
2208 ret = ath10k_vdev_start(arvif);
2209 if (!ret)
2210 ath10k_dbg(ATH10K_DBG_MAC,
2211 "VDEV: %d started with BSSID: %pM\n",
2212 arvif->vdev_id, info->bssid);
2213 }
2214
2215 /*
2216 * Mac80211 does not keep IBSS bssid when leaving IBSS,
2217 * so driver need to store it. It is needed when leaving
2218 * IBSS in order to remove BSSID peer.
2219 */
2220 if (vif->type == NL80211_IFTYPE_ADHOC)
2221 memcpy(arvif->u.ibss.bssid, info->bssid,
2222 ETH_ALEN);
2223 }
2224 }
2225
2226 if (changed & BSS_CHANGED_BEACON_ENABLED)
2227 ath10k_control_beaconing(arvif, info);
2228
2229 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2230 u32 cts_prot;
2231 if (info->use_cts_prot)
2232 cts_prot = 1;
2233 else
2234 cts_prot = 0;
2235
2236 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2237 WMI_VDEV_PARAM_ENABLE_RTSCTS,
2238 cts_prot);
2239 if (ret)
2240 ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
2241 arvif->vdev_id);
2242 else
2243 ath10k_dbg(ATH10K_DBG_MAC,
2244 "Set CTS prot: %d for VDEV: %d\n",
2245 cts_prot, arvif->vdev_id);
2246 }
2247
2248 if (changed & BSS_CHANGED_ERP_SLOT) {
2249 u32 slottime;
2250 if (info->use_short_slot)
2251 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2252
2253 else
2254 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2255
2256 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2257 WMI_VDEV_PARAM_SLOT_TIME,
2258 slottime);
2259 if (ret)
2260 ath10k_warn("Failed to set erp slot for VDEV: %d\n",
2261 arvif->vdev_id);
2262 else
2263 ath10k_dbg(ATH10K_DBG_MAC,
2264 "Set slottime: %d for VDEV: %d\n",
2265 slottime, arvif->vdev_id);
2266 }
2267
2268 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2269 u32 preamble;
2270 if (info->use_short_preamble)
2271 preamble = WMI_VDEV_PREAMBLE_SHORT;
2272 else
2273 preamble = WMI_VDEV_PREAMBLE_LONG;
2274
2275 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2276 WMI_VDEV_PARAM_PREAMBLE,
2277 preamble);
2278 if (ret)
2279 ath10k_warn("Failed to set preamble for VDEV: %d\n",
2280 arvif->vdev_id);
2281 else
2282 ath10k_dbg(ATH10K_DBG_MAC,
2283 "Set preamble: %d for VDEV: %d\n",
2284 preamble, arvif->vdev_id);
2285 }
2286
2287 if (changed & BSS_CHANGED_ASSOC) {
2288 if (info->assoc)
2289 ath10k_bss_assoc(hw, vif, info);
2290 }
2291
2292 mutex_unlock(&ar->conf_mutex);
2293}
2294
2295static int ath10k_hw_scan(struct ieee80211_hw *hw,
2296 struct ieee80211_vif *vif,
2297 struct cfg80211_scan_request *req)
2298{
2299 struct ath10k *ar = hw->priv;
2300 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2301 struct wmi_start_scan_arg arg;
2302 int ret = 0;
2303 int i;
2304
2305 mutex_lock(&ar->conf_mutex);
2306
2307 spin_lock_bh(&ar->data_lock);
2308 if (ar->scan.in_progress) {
2309 spin_unlock_bh(&ar->data_lock);
2310 ret = -EBUSY;
2311 goto exit;
2312 }
2313
2314 INIT_COMPLETION(ar->scan.started);
2315 INIT_COMPLETION(ar->scan.completed);
2316 ar->scan.in_progress = true;
2317 ar->scan.aborting = false;
2318 ar->scan.is_roc = false;
2319 ar->scan.vdev_id = arvif->vdev_id;
2320 spin_unlock_bh(&ar->data_lock);
2321
2322 memset(&arg, 0, sizeof(arg));
2323 ath10k_wmi_start_scan_init(ar, &arg);
2324 arg.vdev_id = arvif->vdev_id;
2325 arg.scan_id = ATH10K_SCAN_ID;
2326
2327 if (!req->no_cck)
2328 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
2329
2330 if (req->ie_len) {
2331 arg.ie_len = req->ie_len;
2332 memcpy(arg.ie, req->ie, arg.ie_len);
2333 }
2334
2335 if (req->n_ssids) {
2336 arg.n_ssids = req->n_ssids;
2337 for (i = 0; i < arg.n_ssids; i++) {
2338 arg.ssids[i].len = req->ssids[i].ssid_len;
2339 arg.ssids[i].ssid = req->ssids[i].ssid;
2340 }
2341 }
2342
2343 if (req->n_channels) {
2344 arg.n_channels = req->n_channels;
2345 for (i = 0; i < arg.n_channels; i++)
2346 arg.channels[i] = req->channels[i]->center_freq;
2347 }
2348
2349 ret = ath10k_start_scan(ar, &arg);
2350 if (ret) {
2351 ath10k_warn("could not start hw scan (%d)\n", ret);
2352 spin_lock_bh(&ar->data_lock);
2353 ar->scan.in_progress = false;
2354 spin_unlock_bh(&ar->data_lock);
2355 }
2356
2357exit:
2358 mutex_unlock(&ar->conf_mutex);
2359 return ret;
2360}
2361
2362static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
2363 struct ieee80211_vif *vif)
2364{
2365 struct ath10k *ar = hw->priv;
2366 int ret;
2367
2368 mutex_lock(&ar->conf_mutex);
2369 ret = ath10k_abort_scan(ar);
2370 if (ret) {
2371 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n",
2372 ret);
2373 ieee80211_scan_completed(hw, 1 /* aborted */);
2374 }
2375 mutex_unlock(&ar->conf_mutex);
2376}
2377
2378static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2379 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
2380 struct ieee80211_key_conf *key)
2381{
2382 struct ath10k *ar = hw->priv;
2383 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2384 struct ath10k_peer *peer;
2385 const u8 *peer_addr;
2386 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2387 key->cipher == WLAN_CIPHER_SUITE_WEP104;
2388 int ret = 0;
2389
2390 if (key->keyidx > WMI_MAX_KEY_INDEX)
2391 return -ENOSPC;
2392
2393 mutex_lock(&ar->conf_mutex);
2394
2395 if (sta)
2396 peer_addr = sta->addr;
2397 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
2398 peer_addr = vif->bss_conf.bssid;
2399 else
2400 peer_addr = vif->addr;
2401
2402 key->hw_key_idx = key->keyidx;
2403
2404 /* the peer should not disappear in mid-way (unless FW goes awry) since
2405 * we already hold conf_mutex. we just make sure its there now. */
2406 spin_lock_bh(&ar->data_lock);
2407 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2408 spin_unlock_bh(&ar->data_lock);
2409
2410 if (!peer) {
2411 if (cmd == SET_KEY) {
2412 ath10k_warn("cannot install key for non-existent peer %pM\n",
2413 peer_addr);
2414 ret = -EOPNOTSUPP;
2415 goto exit;
2416 } else {
2417 /* if the peer doesn't exist there is no key to disable
2418 * anymore */
2419 goto exit;
2420 }
2421 }
2422
2423 if (is_wep) {
2424 if (cmd == SET_KEY)
2425 arvif->wep_keys[key->keyidx] = key;
2426 else
2427 arvif->wep_keys[key->keyidx] = NULL;
2428
2429 if (cmd == DISABLE_KEY)
2430 ath10k_clear_vdev_key(arvif, key);
2431 }
2432
2433 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
2434 if (ret) {
2435 ath10k_warn("ath10k_install_key failed (%d)\n", ret);
2436 goto exit;
2437 }
2438
2439 spin_lock_bh(&ar->data_lock);
2440 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2441 if (peer && cmd == SET_KEY)
2442 peer->keys[key->keyidx] = key;
2443 else if (peer && cmd == DISABLE_KEY)
2444 peer->keys[key->keyidx] = NULL;
2445 else if (peer == NULL)
2446 /* impossible unless FW goes crazy */
2447 ath10k_warn("peer %pM disappeared!\n", peer_addr);
2448 spin_unlock_bh(&ar->data_lock);
2449
2450exit:
2451 mutex_unlock(&ar->conf_mutex);
2452 return ret;
2453}
2454
2455static int ath10k_sta_state(struct ieee80211_hw *hw,
2456 struct ieee80211_vif *vif,
2457 struct ieee80211_sta *sta,
2458 enum ieee80211_sta_state old_state,
2459 enum ieee80211_sta_state new_state)
2460{
2461 struct ath10k *ar = hw->priv;
2462 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2463 int ret = 0;
2464
2465 mutex_lock(&ar->conf_mutex);
2466
2467 if (old_state == IEEE80211_STA_NOTEXIST &&
2468 new_state == IEEE80211_STA_NONE &&
2469 vif->type != NL80211_IFTYPE_STATION) {
2470 /*
2471 * New station addition.
2472 */
2473 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
2474 if (ret)
2475 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2476 sta->addr, arvif->vdev_id);
2477 else
2478 ath10k_dbg(ATH10K_DBG_MAC,
2479 "Added peer: %pM for VDEV: %d\n",
2480 sta->addr, arvif->vdev_id);
2481 } else if ((old_state == IEEE80211_STA_NONE &&
2482 new_state == IEEE80211_STA_NOTEXIST)) {
2483 /*
2484 * Existing station deletion.
2485 */
2486 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
2487 if (ret)
2488 ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
2489 sta->addr, arvif->vdev_id);
2490 else
2491 ath10k_dbg(ATH10K_DBG_MAC,
2492 "Removed peer: %pM for VDEV: %d\n",
2493 sta->addr, arvif->vdev_id);
2494
2495 if (vif->type == NL80211_IFTYPE_STATION)
2496 ath10k_bss_disassoc(hw, vif);
2497 } else if (old_state == IEEE80211_STA_AUTH &&
2498 new_state == IEEE80211_STA_ASSOC &&
2499 (vif->type == NL80211_IFTYPE_AP ||
2500 vif->type == NL80211_IFTYPE_ADHOC)) {
2501 /*
2502 * New association.
2503 */
2504 ret = ath10k_station_assoc(ar, arvif, sta);
2505 if (ret)
2506 ath10k_warn("Failed to associate station: %pM\n",
2507 sta->addr);
2508 else
2509 ath10k_dbg(ATH10K_DBG_MAC,
2510 "Station %pM moved to assoc state\n",
2511 sta->addr);
2512 } else if (old_state == IEEE80211_STA_ASSOC &&
2513 new_state == IEEE80211_STA_AUTH &&
2514 (vif->type == NL80211_IFTYPE_AP ||
2515 vif->type == NL80211_IFTYPE_ADHOC)) {
2516 /*
2517 * Disassociation.
2518 */
2519 ret = ath10k_station_disassoc(ar, arvif, sta);
2520 if (ret)
2521 ath10k_warn("Failed to disassociate station: %pM\n",
2522 sta->addr);
2523 else
2524 ath10k_dbg(ATH10K_DBG_MAC,
2525 "Station %pM moved to disassociated state\n",
2526 sta->addr);
2527 }
2528
2529 mutex_unlock(&ar->conf_mutex);
2530 return ret;
2531}
2532
2533static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
2534 u16 ac, bool enable)
2535{
2536 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2537 u32 value = 0;
2538 int ret = 0;
2539
548db54c
MK		 2540 lockdep_assert_held(&ar->conf_mutex);
2541
5e3dd157
KV		 2542 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
2543 return 0;
2544
2545 switch (ac) {
2546 case IEEE80211_AC_VO:
2547 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
2548 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
2549 break;
2550 case IEEE80211_AC_VI:
2551 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
2552 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
2553 break;
2554 case IEEE80211_AC_BE:
2555 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
2556 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
2557 break;
2558 case IEEE80211_AC_BK:
2559 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
2560 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
2561 break;
2562 }
2563
2564 if (enable)
2565 arvif->u.sta.uapsd |= value;
2566 else
2567 arvif->u.sta.uapsd &= ~value;
2568
2569 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2570 WMI_STA_PS_PARAM_UAPSD,
2571 arvif->u.sta.uapsd);
2572 if (ret) {
2573 ath10k_warn("could not set uapsd params %d\n", ret);
2574 goto exit;
2575 }
2576
2577 if (arvif->u.sta.uapsd)
2578 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
2579 else
2580 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2581
2582 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2583 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
2584 value);
2585 if (ret)
2586 ath10k_warn("could not set rx wake param %d\n", ret);
2587
2588exit:
2589 return ret;
2590}
2591
2592static int ath10k_conf_tx(struct ieee80211_hw *hw,
2593 struct ieee80211_vif *vif, u16 ac,
2594 const struct ieee80211_tx_queue_params *params)
2595{
2596 struct ath10k *ar = hw->priv;
2597 struct wmi_wmm_params_arg *p = NULL;
2598 int ret;
2599
2600 mutex_lock(&ar->conf_mutex);
2601
2602 switch (ac) {
2603 case IEEE80211_AC_VO:
2604 p = &ar->wmm_params.ac_vo;
2605 break;
2606 case IEEE80211_AC_VI:
2607 p = &ar->wmm_params.ac_vi;
2608 break;
2609 case IEEE80211_AC_BE:
2610 p = &ar->wmm_params.ac_be;
2611 break;
2612 case IEEE80211_AC_BK:
2613 p = &ar->wmm_params.ac_bk;
2614 break;
2615 }
2616
2617 if (WARN_ON(!p)) {
2618 ret = -EINVAL;
2619 goto exit;
2620 }
2621
2622 p->cwmin = params->cw_min;
2623 p->cwmax = params->cw_max;
2624 p->aifs = params->aifs;
2625
2626 /*
2627 * The channel time duration programmed in the HW is in absolute
2628 * microseconds, while mac80211 gives the txop in units of
2629 * 32 microseconds.
2630 */
2631 p->txop = params->txop * 32;
2632
2633 /* FIXME: FW accepts wmm params per hw, not per vif */
2634 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
2635 if (ret) {
2636 ath10k_warn("could not set wmm params %d\n", ret);
2637 goto exit;
2638 }
2639
2640 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
2641 if (ret)
2642 ath10k_warn("could not set sta uapsd %d\n", ret);
2643
2644exit:
2645 mutex_unlock(&ar->conf_mutex);
2646 return ret;
2647}
2648
2649#define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
2650
2651static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
2652 struct ieee80211_vif *vif,
2653 struct ieee80211_channel *chan,
2654 int duration,
2655 enum ieee80211_roc_type type)
2656{
2657 struct ath10k *ar = hw->priv;
2658 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2659 struct wmi_start_scan_arg arg;
2660 int ret;
2661
2662 mutex_lock(&ar->conf_mutex);
2663
2664 spin_lock_bh(&ar->data_lock);
2665 if (ar->scan.in_progress) {
2666 spin_unlock_bh(&ar->data_lock);
2667 ret = -EBUSY;
2668 goto exit;
2669 }
2670
2671 INIT_COMPLETION(ar->scan.started);
2672 INIT_COMPLETION(ar->scan.completed);
2673 INIT_COMPLETION(ar->scan.on_channel);
2674 ar->scan.in_progress = true;
2675 ar->scan.aborting = false;
2676 ar->scan.is_roc = true;
2677 ar->scan.vdev_id = arvif->vdev_id;
2678 ar->scan.roc_freq = chan->center_freq;
2679 spin_unlock_bh(&ar->data_lock);
2680
2681 memset(&arg, 0, sizeof(arg));
2682 ath10k_wmi_start_scan_init(ar, &arg);
2683 arg.vdev_id = arvif->vdev_id;
2684 arg.scan_id = ATH10K_SCAN_ID;
2685 arg.n_channels = 1;
2686 arg.channels[0] = chan->center_freq;
2687 arg.dwell_time_active = duration;
2688 arg.dwell_time_passive = duration;
2689 arg.max_scan_time = 2 * duration;
2690 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
2691 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
2692
2693 ret = ath10k_start_scan(ar, &arg);
2694 if (ret) {
2695 ath10k_warn("could not start roc scan (%d)\n", ret);
2696 spin_lock_bh(&ar->data_lock);
2697 ar->scan.in_progress = false;
2698 spin_unlock_bh(&ar->data_lock);
2699 goto exit;
2700 }
2701
2702 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
2703 if (ret == 0) {
2704 ath10k_warn("could not switch to channel for roc scan\n");
2705 ath10k_abort_scan(ar);
2706 ret = -ETIMEDOUT;
2707 goto exit;
2708 }
2709
2710 ret = 0;
2711exit:
2712 mutex_unlock(&ar->conf_mutex);
2713 return ret;
2714}
2715
2716static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
2717{
2718 struct ath10k *ar = hw->priv;
2719
2720 mutex_lock(&ar->conf_mutex);
2721 ath10k_abort_scan(ar);
2722 mutex_unlock(&ar->conf_mutex);
2723
2724 return 0;
2725}
2726
2727/*
2728 * Both RTS and Fragmentation threshold are interface-specific
2729 * in ath10k, but device-specific in mac80211.
2730 */
2731static void ath10k_set_rts_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2732{
2733 struct ath10k_generic_iter *ar_iter = data;
2734 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2735 u32 rts = ar_iter->ar->hw->wiphy->rts_threshold;
2736
548db54c
MK		 2737 lockdep_assert_held(&arvif->ar->conf_mutex);
2738
affd3217
MK		 2739 /* During HW reconfiguration mac80211 reports all interfaces that were
2740 * running until reconfiguration was started. Since FW doesn't have any
2741 * vdevs at this point we must not iterate over this interface list.
2742 * This setting will be updated upon add_interface(). */
2743 if (ar_iter->ar->state == ATH10K_STATE_RESTARTED)
2744 return;
2745
424121c3 2746 ar_iter->ret = ath10k_mac_set_rts(arvif, rts);
5e3dd157
KV		 2747 if (ar_iter->ret)
2748 ath10k_warn("Failed to set RTS threshold for VDEV: %d\n",
2749 arvif->vdev_id);
2750 else
2751 ath10k_dbg(ATH10K_DBG_MAC,
2752 "Set RTS threshold: %d for VDEV: %d\n",
2753 rts, arvif->vdev_id);
2754}
2755
2756static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2757{
2758 struct ath10k_generic_iter ar_iter;
2759 struct ath10k *ar = hw->priv;
2760
2761 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2762 ar_iter.ar = ar;
2763
2764 mutex_lock(&ar->conf_mutex);
80c78c67 2765 ieee80211_iterate_active_interfaces_atomic(
671b96db 2766 hw, IEEE80211_IFACE_ITER_NORMAL,
80c78c67 2767 ath10k_set_rts_iter, &ar_iter);
5e3dd157
KV		 2768 mutex_unlock(&ar->conf_mutex);
2769
2770 return ar_iter.ret;
2771}
2772
2773static void ath10k_set_frag_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2774{
2775 struct ath10k_generic_iter *ar_iter = data;
2776 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2777 u32 frag = ar_iter->ar->hw->wiphy->frag_threshold;
5e3dd157 2778
548db54c
MK		 2779 lockdep_assert_held(&arvif->ar->conf_mutex);
2780
affd3217
MK		 2781 /* During HW reconfiguration mac80211 reports all interfaces that were
2782 * running until reconfiguration was started. Since FW doesn't have any
2783 * vdevs at this point we must not iterate over this interface list.
2784 * This setting will be updated upon add_interface(). */
2785 if (ar_iter->ar->state == ATH10K_STATE_RESTARTED)
2786 return;
2787
424121c3 2788 ar_iter->ret = ath10k_mac_set_frag(arvif, frag);
5e3dd157
KV		 2789 if (ar_iter->ret)
2790 ath10k_warn("Failed to set frag threshold for VDEV: %d\n",
2791 arvif->vdev_id);
2792 else
2793 ath10k_dbg(ATH10K_DBG_MAC,
2794 "Set frag threshold: %d for VDEV: %d\n",
2795 frag, arvif->vdev_id);
2796}
2797
2798static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2799{
2800 struct ath10k_generic_iter ar_iter;
2801 struct ath10k *ar = hw->priv;
2802
2803 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2804 ar_iter.ar = ar;
2805
2806 mutex_lock(&ar->conf_mutex);
80c78c67 2807 ieee80211_iterate_active_interfaces_atomic(
671b96db 2808 hw, IEEE80211_IFACE_ITER_NORMAL,
80c78c67 2809 ath10k_set_frag_iter, &ar_iter);
5e3dd157
KV		 2810 mutex_unlock(&ar->conf_mutex);
2811
2812 return ar_iter.ret;
2813}
2814
2815static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
2816{
2817 struct ath10k *ar = hw->priv;
affd3217 2818 bool skip;
5e3dd157
KV		 2819 int ret;
2820
2821 /* mac80211 doesn't care if we really xmit queued frames or not
2822 * we'll collect those frames either way if we stop/delete vdevs */
2823 if (drop)
2824 return;
2825
548db54c
MK		 2826 mutex_lock(&ar->conf_mutex);
2827
affd3217
MK		 2828 if (ar->state == ATH10K_STATE_WEDGED)
2829 goto skip;
2830
edb8236d 2831 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
5e3dd157 2832 bool empty;
affd3217 2833
edb8236d
MK		 2834 spin_lock_bh(&ar->htt.tx_lock);
2835 empty = bitmap_empty(ar->htt.used_msdu_ids,
2836 ar->htt.max_num_pending_tx);
2837 spin_unlock_bh(&ar->htt.tx_lock);
affd3217
MK		 2838
2839 skip = (ar->state == ATH10K_STATE_WEDGED);
2840
2841 (empty || skip);
5e3dd157 2842 }), ATH10K_FLUSH_TIMEOUT_HZ);
affd3217
MK		 2843
2844 if (ret <= 0 || skip)
5e3dd157 2845 ath10k_warn("tx not flushed\n");
548db54c 2846
affd3217 2847skip:
548db54c 2848 mutex_unlock(&ar->conf_mutex);
5e3dd157
KV		 2849}
2850
2851/* TODO: Implement this function properly
2852 * For now it is needed to reply to Probe Requests in IBSS mode.
2853 * Propably we need this information from FW.
2854 */
2855static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
2856{
2857 return 1;
2858}
2859
8cd13cad
MK		 2860#ifdef CONFIG_PM
2861static int ath10k_suspend(struct ieee80211_hw *hw,
2862 struct cfg80211_wowlan *wowlan)
2863{
2864 struct ath10k *ar = hw->priv;
2865 int ret;
2866
2867 ar->is_target_paused = false;
2868
2869 ret = ath10k_wmi_pdev_suspend_target(ar);
2870 if (ret) {
2871 ath10k_warn("could not suspend target (%d)\n", ret);
2872 return 1;
2873 }
2874
2875 ret = wait_event_interruptible_timeout(ar->event_queue,
2876 ar->is_target_paused == true,
2877 1 * HZ);
2878 if (ret < 0) {
2879 ath10k_warn("suspend interrupted (%d)\n", ret);
2880 goto resume;
2881 } else if (ret == 0) {
2882 ath10k_warn("suspend timed out - target pause event never came\n");
2883 goto resume;
2884 }
2885
2886 ret = ath10k_hif_suspend(ar);
2887 if (ret) {
2888 ath10k_warn("could not suspend hif (%d)\n", ret);
2889 goto resume;
2890 }
2891
2892 return 0;
2893resume:
2894 ret = ath10k_wmi_pdev_resume_target(ar);
2895 if (ret)
2896 ath10k_warn("could not resume target (%d)\n", ret);
2897 return 1;
2898}
2899
2900static int ath10k_resume(struct ieee80211_hw *hw)
2901{
2902 struct ath10k *ar = hw->priv;
2903 int ret;
2904
2905 ret = ath10k_hif_resume(ar);
2906 if (ret) {
2907 ath10k_warn("could not resume hif (%d)\n", ret);
2908 return 1;
2909 }
2910
2911 ret = ath10k_wmi_pdev_resume_target(ar);
2912 if (ret) {
2913 ath10k_warn("could not resume target (%d)\n", ret);
2914 return 1;
2915 }
2916
2917 return 0;
2918}
2919#endif
2920
affd3217
MK		 2921static void ath10k_restart_complete(struct ieee80211_hw *hw)
2922{
2923 struct ath10k *ar = hw->priv;
2924
2925 mutex_lock(&ar->conf_mutex);
2926
2927 /* If device failed to restart it will be in a different state, e.g.
2928 * ATH10K_STATE_WEDGED */
2929 if (ar->state == ATH10K_STATE_RESTARTED) {
2930 ath10k_info("device successfully recovered\n");
2931 ar->state = ATH10K_STATE_ON;
2932 }
2933
2934 mutex_unlock(&ar->conf_mutex);
2935}
2936
5e3dd157
KV		 2937static const struct ieee80211_ops ath10k_ops = {
2938 .tx = ath10k_tx,
2939 .start = ath10k_start,
2940 .stop = ath10k_stop,
2941 .config = ath10k_config,
2942 .add_interface = ath10k_add_interface,
2943 .remove_interface = ath10k_remove_interface,
2944 .configure_filter = ath10k_configure_filter,
2945 .bss_info_changed = ath10k_bss_info_changed,
2946 .hw_scan = ath10k_hw_scan,
2947 .cancel_hw_scan = ath10k_cancel_hw_scan,
2948 .set_key = ath10k_set_key,
2949 .sta_state = ath10k_sta_state,
2950 .conf_tx = ath10k_conf_tx,
2951 .remain_on_channel = ath10k_remain_on_channel,
2952 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
2953 .set_rts_threshold = ath10k_set_rts_threshold,
2954 .set_frag_threshold = ath10k_set_frag_threshold,
2955 .flush = ath10k_flush,
2956 .tx_last_beacon = ath10k_tx_last_beacon,
affd3217 2957 .restart_complete = ath10k_restart_complete,
8cd13cad
MK		 2958#ifdef CONFIG_PM
2959 .suspend = ath10k_suspend,
2960 .resume = ath10k_resume,
2961#endif
5e3dd157
KV		 2962};
2963
2964#define RATETAB_ENT(_rate, _rateid, _flags) { \
2965 .bitrate = (_rate), \
2966 .flags = (_flags), \
2967 .hw_value = (_rateid), \
2968}
2969
2970#define CHAN2G(_channel, _freq, _flags) { \
2971 .band = IEEE80211_BAND_2GHZ, \
2972 .hw_value = (_channel), \
2973 .center_freq = (_freq), \
2974 .flags = (_flags), \
2975 .max_antenna_gain = 0, \
2976 .max_power = 30, \
2977}
2978
2979#define CHAN5G(_channel, _freq, _flags) { \
2980 .band = IEEE80211_BAND_5GHZ, \
2981 .hw_value = (_channel), \
2982 .center_freq = (_freq), \
2983 .flags = (_flags), \
2984 .max_antenna_gain = 0, \
2985 .max_power = 30, \
2986}
2987
2988static const struct ieee80211_channel ath10k_2ghz_channels[] = {
2989 CHAN2G(1, 2412, 0),
2990 CHAN2G(2, 2417, 0),
2991 CHAN2G(3, 2422, 0),
2992 CHAN2G(4, 2427, 0),
2993 CHAN2G(5, 2432, 0),
2994 CHAN2G(6, 2437, 0),
2995 CHAN2G(7, 2442, 0),
2996 CHAN2G(8, 2447, 0),
2997 CHAN2G(9, 2452, 0),
2998 CHAN2G(10, 2457, 0),
2999 CHAN2G(11, 2462, 0),
3000 CHAN2G(12, 2467, 0),
3001 CHAN2G(13, 2472, 0),
3002 CHAN2G(14, 2484, 0),
3003};
3004
3005static const struct ieee80211_channel ath10k_5ghz_channels[] = {
429ff56a
MK		 3006 CHAN5G(36, 5180, 0),
3007 CHAN5G(40, 5200, 0),
3008 CHAN5G(44, 5220, 0),
3009 CHAN5G(48, 5240, 0),
3010 CHAN5G(52, 5260, 0),
3011 CHAN5G(56, 5280, 0),
3012 CHAN5G(60, 5300, 0),
3013 CHAN5G(64, 5320, 0),
3014 CHAN5G(100, 5500, 0),
3015 CHAN5G(104, 5520, 0),
3016 CHAN5G(108, 5540, 0),
3017 CHAN5G(112, 5560, 0),
3018 CHAN5G(116, 5580, 0),
3019 CHAN5G(120, 5600, 0),
3020 CHAN5G(124, 5620, 0),
3021 CHAN5G(128, 5640, 0),
3022 CHAN5G(132, 5660, 0),
3023 CHAN5G(136, 5680, 0),
3024 CHAN5G(140, 5700, 0),
3025 CHAN5G(149, 5745, 0),
3026 CHAN5G(153, 5765, 0),
3027 CHAN5G(157, 5785, 0),
3028 CHAN5G(161, 5805, 0),
3029 CHAN5G(165, 5825, 0),
5e3dd157
KV		 3030};
3031
3032static struct ieee80211_rate ath10k_rates[] = {
3033 /* CCK */
3034 RATETAB_ENT(10, 0x82, 0),
3035 RATETAB_ENT(20, 0x84, 0),
3036 RATETAB_ENT(55, 0x8b, 0),
3037 RATETAB_ENT(110, 0x96, 0),
3038 /* OFDM */
3039 RATETAB_ENT(60, 0x0c, 0),
3040 RATETAB_ENT(90, 0x12, 0),
3041 RATETAB_ENT(120, 0x18, 0),
3042 RATETAB_ENT(180, 0x24, 0),
3043 RATETAB_ENT(240, 0x30, 0),
3044 RATETAB_ENT(360, 0x48, 0),
3045 RATETAB_ENT(480, 0x60, 0),
3046 RATETAB_ENT(540, 0x6c, 0),
3047};
3048
3049#define ath10k_a_rates (ath10k_rates + 4)
3050#define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
3051#define ath10k_g_rates (ath10k_rates + 0)
3052#define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
3053
3054struct ath10k *ath10k_mac_create(void)
3055{
3056 struct ieee80211_hw *hw;
3057 struct ath10k *ar;
3058
3059 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
3060 if (!hw)
3061 return NULL;
3062
3063 ar = hw->priv;
3064 ar->hw = hw;
3065
3066 return ar;
3067}
3068
3069void ath10k_mac_destroy(struct ath10k *ar)
3070{
3071 ieee80211_free_hw(ar->hw);
3072}
3073
3074static const struct ieee80211_iface_limit ath10k_if_limits[] = {
3075 {
3076 .max = 8,
3077 .types = BIT(NL80211_IFTYPE_STATION)
3078 | BIT(NL80211_IFTYPE_P2P_CLIENT)
3079 | BIT(NL80211_IFTYPE_P2P_GO)
3080 | BIT(NL80211_IFTYPE_AP)
3081 }
3082};
3083
3084static const struct ieee80211_iface_combination ath10k_if_comb = {
3085 .limits = ath10k_if_limits,
3086 .n_limits = ARRAY_SIZE(ath10k_if_limits),
3087 .max_interfaces = 8,
3088 .num_different_channels = 1,
3089 .beacon_int_infra_match = true,
3090};
3091
3092static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3093{
3094 struct ieee80211_sta_vht_cap vht_cap = {0};
3095 u16 mcs_map;
3096
3097 vht_cap.vht_supported = 1;
3098 vht_cap.cap = ar->vht_cap_info;
3099
3100 /* FIXME: check dynamically how many streams board supports */
3101 mcs_map = IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
3102 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
3103 IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
3104 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
3105 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
3106 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
3107 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
3108 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14;
3109
3110 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3111 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3112
3113 return vht_cap;
3114}
3115
3116static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3117{
3118 int i;
3119 struct ieee80211_sta_ht_cap ht_cap = {0};
3120
3121 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3122 return ht_cap;
3123
3124 ht_cap.ht_supported = 1;
3125 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3126 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3127 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3128 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3129 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
3130
3131 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3132 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3133
3134 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3135 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3136
3137 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3138 u32 smps;
3139
3140 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
3141 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3142
3143 ht_cap.cap |= smps;
3144 }
3145
3146 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3147 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3148
3149 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3150 u32 stbc;
3151
3152 stbc = ar->ht_cap_info;
3153 stbc &= WMI_HT_CAP_RX_STBC;
3154 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3155 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3156 stbc &= IEEE80211_HT_CAP_RX_STBC;
3157
3158 ht_cap.cap |= stbc;
3159 }
3160
3161 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3162 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3163
3164 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3165 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3166
3167 /* max AMSDU is implicitly taken from vht_cap_info */
3168 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3169 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3170
3171 for (i = 0; i < WMI_MAX_SPATIAL_STREAM; i++)
3172 ht_cap.mcs.rx_mask[i] = 0xFF;
3173
3174 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3175
3176 return ht_cap;
3177}
3178
3179
3180static void ath10k_get_arvif_iter(void *data, u8 *mac,
3181 struct ieee80211_vif *vif)
3182{
3183 struct ath10k_vif_iter *arvif_iter = data;
3184 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3185
3186 if (arvif->vdev_id == arvif_iter->vdev_id)
3187 arvif_iter->arvif = arvif;
3188}
3189
3190struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
3191{
3192 struct ath10k_vif_iter arvif_iter;
3193 u32 flags;
3194
3195 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
3196 arvif_iter.vdev_id = vdev_id;
3197
3198 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
3199 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3200 flags,
3201 ath10k_get_arvif_iter,
3202 &arvif_iter);
3203 if (!arvif_iter.arvif) {
3204 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
3205 return NULL;
3206 }
3207
3208 return arvif_iter.arvif;
3209}
3210
3211int ath10k_mac_register(struct ath10k *ar)
3212{
3213 struct ieee80211_supported_band *band;
3214 struct ieee80211_sta_vht_cap vht_cap;
3215 struct ieee80211_sta_ht_cap ht_cap;
3216 void *channels;
3217 int ret;
3218
3219 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
3220
3221 SET_IEEE80211_DEV(ar->hw, ar->dev);
3222
3223 ht_cap = ath10k_get_ht_cap(ar);
3224 vht_cap = ath10k_create_vht_cap(ar);
3225
3226 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3227 channels = kmemdup(ath10k_2ghz_channels,
3228 sizeof(ath10k_2ghz_channels),
3229 GFP_KERNEL);
d6015b27
MK		 3230 if (!channels) {
3231 ret = -ENOMEM;
3232 goto err_free;
3233 }
5e3dd157
KV		 3234
3235 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3236 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
3237 band->channels = channels;
3238 band->n_bitrates = ath10k_g_rates_size;
3239 band->bitrates = ath10k_g_rates;
3240 band->ht_cap = ht_cap;
3241
3242 /* vht is not supported in 2.4 GHz */
3243
3244 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
3245 }
3246
3247 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3248 channels = kmemdup(ath10k_5ghz_channels,
3249 sizeof(ath10k_5ghz_channels),
3250 GFP_KERNEL);
3251 if (!channels) {
d6015b27
MK		 3252 ret = -ENOMEM;
3253 goto err_free;
5e3dd157
KV		 3254 }
3255
3256 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3257 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
3258 band->channels = channels;
3259 band->n_bitrates = ath10k_a_rates_size;
3260 band->bitrates = ath10k_a_rates;
3261 band->ht_cap = ht_cap;
3262 band->vht_cap = vht_cap;
3263 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
3264 }
3265
3266 ar->hw->wiphy->interface_modes =
3267 BIT(NL80211_IFTYPE_STATION) |
3268 BIT(NL80211_IFTYPE_ADHOC) |
3269 BIT(NL80211_IFTYPE_AP) |
3270 BIT(NL80211_IFTYPE_P2P_CLIENT) |
3271 BIT(NL80211_IFTYPE_P2P_GO);
3272
3273 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3274 IEEE80211_HW_SUPPORTS_PS |
3275 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
3276 IEEE80211_HW_SUPPORTS_UAPSD |
3277 IEEE80211_HW_MFP_CAPABLE |
3278 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3279 IEEE80211_HW_HAS_RATE_CONTROL |
3280 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
3281 IEEE80211_HW_WANT_MONITOR_VIF |
3282 IEEE80211_HW_AP_LINK_PS;
3283
3284 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
3285 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
3286
3287 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
3288 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
3289 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
3290 }
3291
3292 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
3293 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
3294
3295 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
3296
3297 ar->hw->channel_change_time = 5000;
3298 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
3299
3300 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3301 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
3302
3303 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
3304 /*
3305 * on LL hardware queues are managed entirely by the FW
3306 * so we only advertise to mac we can do the queues thing
3307 */
3308 ar->hw->queues = 4;
3309
3310 ar->hw->wiphy->iface_combinations = &ath10k_if_comb;
3311 ar->hw->wiphy->n_iface_combinations = 1;
3312
3313 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
3314 ath10k_reg_notifier);
3315 if (ret) {
3316 ath10k_err("Regulatory initialization failed\n");
d6015b27 3317 goto err_free;
5e3dd157
KV		 3318 }
3319
3320 ret = ieee80211_register_hw(ar->hw);
3321 if (ret) {
3322 ath10k_err("ieee80211 registration failed: %d\n", ret);
d6015b27 3323 goto err_free;
5e3dd157
KV		 3324 }
3325
3326 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
3327 ret = regulatory_hint(ar->hw->wiphy,
3328 ar->ath_common.regulatory.alpha2);
3329 if (ret)
d6015b27 3330 goto err_unregister;
5e3dd157
KV		 3331 }
3332
3333 return 0;
d6015b27
MK		 3334
3335err_unregister:
5e3dd157 3336 ieee80211_unregister_hw(ar->hw);
d6015b27
MK		 3337err_free:
3338 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3339 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3340
5e3dd157
KV		 3341 return ret;
3342}
3343
3344void ath10k_mac_unregister(struct ath10k *ar)
3345{
3346 ieee80211_unregister_hw(ar->hw);
3347
3348 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3349 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3350
3351 SET_IEEE80211_DEV(ar->hw, NULL);
3352}
Linux kernel - Deliverables
This page took 0.283769 seconds and 5 git commands to generate.