2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
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.
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.
20 #include <net/mac80211.h>
21 #include <linux/etherdevice.h>
35 static int ath10k_send_key(struct ath10k_vif
*arvif
,
36 struct ieee80211_key_conf
*key
,
40 struct ath10k
*ar
= arvif
->ar
;
41 struct wmi_vdev_install_key_arg arg
= {
42 .vdev_id
= arvif
->vdev_id
,
43 .key_idx
= key
->keyidx
,
44 .key_len
= key
->keylen
,
49 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
51 if (key
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
)
52 arg
.key_flags
= WMI_KEY_PAIRWISE
;
54 arg
.key_flags
= WMI_KEY_GROUP
;
56 switch (key
->cipher
) {
57 case WLAN_CIPHER_SUITE_CCMP
:
58 arg
.key_cipher
= WMI_CIPHER_AES_CCM
;
59 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
)
60 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT
;
62 key
->flags
|= IEEE80211_KEY_FLAG_SW_MGMT_TX
;
64 case WLAN_CIPHER_SUITE_TKIP
:
65 arg
.key_cipher
= WMI_CIPHER_TKIP
;
66 arg
.key_txmic_len
= 8;
67 arg
.key_rxmic_len
= 8;
69 case WLAN_CIPHER_SUITE_WEP40
:
70 case WLAN_CIPHER_SUITE_WEP104
:
71 arg
.key_cipher
= WMI_CIPHER_WEP
;
72 /* AP/IBSS mode requires self-key to be groupwise
73 * Otherwise pairwise key must be set */
74 if (memcmp(macaddr
, arvif
->vif
->addr
, ETH_ALEN
))
75 arg
.key_flags
= WMI_KEY_PAIRWISE
;
78 ath10k_warn(ar
, "cipher %d is not supported\n", key
->cipher
);
82 if (cmd
== DISABLE_KEY
) {
83 arg
.key_cipher
= WMI_CIPHER_NONE
;
87 return ath10k_wmi_vdev_install_key(arvif
->ar
, &arg
);
90 static int ath10k_install_key(struct ath10k_vif
*arvif
,
91 struct ieee80211_key_conf
*key
,
95 struct ath10k
*ar
= arvif
->ar
;
98 lockdep_assert_held(&ar
->conf_mutex
);
100 reinit_completion(&ar
->install_key_done
);
102 ret
= ath10k_send_key(arvif
, key
, cmd
, macaddr
);
106 ret
= wait_for_completion_timeout(&ar
->install_key_done
, 3*HZ
);
113 static int ath10k_install_peer_wep_keys(struct ath10k_vif
*arvif
,
116 struct ath10k
*ar
= arvif
->ar
;
117 struct ath10k_peer
*peer
;
121 lockdep_assert_held(&ar
->conf_mutex
);
123 spin_lock_bh(&ar
->data_lock
);
124 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, addr
);
125 spin_unlock_bh(&ar
->data_lock
);
130 for (i
= 0; i
< ARRAY_SIZE(arvif
->wep_keys
); i
++) {
131 if (arvif
->wep_keys
[i
] == NULL
)
134 ret
= ath10k_install_key(arvif
, arvif
->wep_keys
[i
], SET_KEY
,
139 peer
->keys
[i
] = arvif
->wep_keys
[i
];
145 static int ath10k_clear_peer_keys(struct ath10k_vif
*arvif
,
148 struct ath10k
*ar
= arvif
->ar
;
149 struct ath10k_peer
*peer
;
154 lockdep_assert_held(&ar
->conf_mutex
);
156 spin_lock_bh(&ar
->data_lock
);
157 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, addr
);
158 spin_unlock_bh(&ar
->data_lock
);
163 for (i
= 0; i
< ARRAY_SIZE(peer
->keys
); i
++) {
164 if (peer
->keys
[i
] == NULL
)
167 ret
= ath10k_install_key(arvif
, peer
->keys
[i
],
169 if (ret
&& first_errno
== 0)
173 ath10k_warn(ar
, "failed to remove peer wep key %d: %d\n",
176 peer
->keys
[i
] = NULL
;
182 static int ath10k_clear_vdev_key(struct ath10k_vif
*arvif
,
183 struct ieee80211_key_conf
*key
)
185 struct ath10k
*ar
= arvif
->ar
;
186 struct ath10k_peer
*peer
;
192 lockdep_assert_held(&ar
->conf_mutex
);
195 /* since ath10k_install_key we can't hold data_lock all the
196 * time, so we try to remove the keys incrementally */
197 spin_lock_bh(&ar
->data_lock
);
199 list_for_each_entry(peer
, &ar
->peers
, list
) {
200 for (i
= 0; i
< ARRAY_SIZE(peer
->keys
); i
++) {
201 if (peer
->keys
[i
] == key
) {
202 ether_addr_copy(addr
, peer
->addr
);
203 peer
->keys
[i
] = NULL
;
208 if (i
< ARRAY_SIZE(peer
->keys
))
211 spin_unlock_bh(&ar
->data_lock
);
213 if (i
== ARRAY_SIZE(peer
->keys
))
216 ret
= ath10k_install_key(arvif
, key
, DISABLE_KEY
, addr
);
217 if (ret
&& first_errno
== 0)
221 ath10k_warn(ar
, "failed to remove key for %pM: %d\n",
228 /*********************/
229 /* General utilities */
230 /*********************/
232 static inline enum wmi_phy_mode
233 chan_to_phymode(const struct cfg80211_chan_def
*chandef
)
235 enum wmi_phy_mode phymode
= MODE_UNKNOWN
;
237 switch (chandef
->chan
->band
) {
238 case IEEE80211_BAND_2GHZ
:
239 switch (chandef
->width
) {
240 case NL80211_CHAN_WIDTH_20_NOHT
:
243 case NL80211_CHAN_WIDTH_20
:
244 phymode
= MODE_11NG_HT20
;
246 case NL80211_CHAN_WIDTH_40
:
247 phymode
= MODE_11NG_HT40
;
249 case NL80211_CHAN_WIDTH_5
:
250 case NL80211_CHAN_WIDTH_10
:
251 case NL80211_CHAN_WIDTH_80
:
252 case NL80211_CHAN_WIDTH_80P80
:
253 case NL80211_CHAN_WIDTH_160
:
254 phymode
= MODE_UNKNOWN
;
258 case IEEE80211_BAND_5GHZ
:
259 switch (chandef
->width
) {
260 case NL80211_CHAN_WIDTH_20_NOHT
:
263 case NL80211_CHAN_WIDTH_20
:
264 phymode
= MODE_11NA_HT20
;
266 case NL80211_CHAN_WIDTH_40
:
267 phymode
= MODE_11NA_HT40
;
269 case NL80211_CHAN_WIDTH_80
:
270 phymode
= MODE_11AC_VHT80
;
272 case NL80211_CHAN_WIDTH_5
:
273 case NL80211_CHAN_WIDTH_10
:
274 case NL80211_CHAN_WIDTH_80P80
:
275 case NL80211_CHAN_WIDTH_160
:
276 phymode
= MODE_UNKNOWN
;
284 WARN_ON(phymode
== MODE_UNKNOWN
);
288 static u8
ath10k_parse_mpdudensity(u8 mpdudensity
)
291 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
292 * 0 for no restriction
301 switch (mpdudensity
) {
307 /* Our lower layer calculations limit our precision to
323 static int ath10k_peer_create(struct ath10k
*ar
, u32 vdev_id
, const u8
*addr
)
327 lockdep_assert_held(&ar
->conf_mutex
);
329 ret
= ath10k_wmi_peer_create(ar
, vdev_id
, addr
);
331 ath10k_warn(ar
, "failed to create wmi peer %pM on vdev %i: %i\n",
336 ret
= ath10k_wait_for_peer_created(ar
, vdev_id
, addr
);
338 ath10k_warn(ar
, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
342 spin_lock_bh(&ar
->data_lock
);
344 spin_unlock_bh(&ar
->data_lock
);
349 static int ath10k_mac_set_kickout(struct ath10k_vif
*arvif
)
351 struct ath10k
*ar
= arvif
->ar
;
355 param
= ar
->wmi
.pdev_param
->sta_kickout_th
;
356 ret
= ath10k_wmi_pdev_set_param(ar
, param
,
357 ATH10K_KICKOUT_THRESHOLD
);
359 ath10k_warn(ar
, "failed to set kickout threshold on vdev %i: %d\n",
360 arvif
->vdev_id
, ret
);
364 param
= ar
->wmi
.vdev_param
->ap_keepalive_min_idle_inactive_time_secs
;
365 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, param
,
366 ATH10K_KEEPALIVE_MIN_IDLE
);
368 ath10k_warn(ar
, "failed to set keepalive minimum idle time on vdev %i: %d\n",
369 arvif
->vdev_id
, ret
);
373 param
= ar
->wmi
.vdev_param
->ap_keepalive_max_idle_inactive_time_secs
;
374 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, param
,
375 ATH10K_KEEPALIVE_MAX_IDLE
);
377 ath10k_warn(ar
, "failed to set keepalive maximum idle time on vdev %i: %d\n",
378 arvif
->vdev_id
, ret
);
382 param
= ar
->wmi
.vdev_param
->ap_keepalive_max_unresponsive_time_secs
;
383 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, param
,
384 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE
);
386 ath10k_warn(ar
, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
387 arvif
->vdev_id
, ret
);
394 static int ath10k_mac_set_rts(struct ath10k_vif
*arvif
, u32 value
)
396 struct ath10k
*ar
= arvif
->ar
;
399 if (value
!= 0xFFFFFFFF)
400 value
= min_t(u32
, arvif
->ar
->hw
->wiphy
->rts_threshold
,
403 vdev_param
= ar
->wmi
.vdev_param
->rts_threshold
;
404 return ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
, value
);
407 static int ath10k_mac_set_frag(struct ath10k_vif
*arvif
, u32 value
)
409 struct ath10k
*ar
= arvif
->ar
;
412 if (value
!= 0xFFFFFFFF)
413 value
= clamp_t(u32
, arvif
->ar
->hw
->wiphy
->frag_threshold
,
414 ATH10K_FRAGMT_THRESHOLD_MIN
,
415 ATH10K_FRAGMT_THRESHOLD_MAX
);
417 vdev_param
= ar
->wmi
.vdev_param
->fragmentation_threshold
;
418 return ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
, value
);
421 static int ath10k_peer_delete(struct ath10k
*ar
, u32 vdev_id
, const u8
*addr
)
425 lockdep_assert_held(&ar
->conf_mutex
);
427 ret
= ath10k_wmi_peer_delete(ar
, vdev_id
, addr
);
431 ret
= ath10k_wait_for_peer_deleted(ar
, vdev_id
, addr
);
435 spin_lock_bh(&ar
->data_lock
);
437 spin_unlock_bh(&ar
->data_lock
);
442 static void ath10k_peer_cleanup(struct ath10k
*ar
, u32 vdev_id
)
444 struct ath10k_peer
*peer
, *tmp
;
446 lockdep_assert_held(&ar
->conf_mutex
);
448 spin_lock_bh(&ar
->data_lock
);
449 list_for_each_entry_safe(peer
, tmp
, &ar
->peers
, list
) {
450 if (peer
->vdev_id
!= vdev_id
)
453 ath10k_warn(ar
, "removing stale peer %pM from vdev_id %d\n",
454 peer
->addr
, vdev_id
);
456 list_del(&peer
->list
);
460 spin_unlock_bh(&ar
->data_lock
);
463 static void ath10k_peer_cleanup_all(struct ath10k
*ar
)
465 struct ath10k_peer
*peer
, *tmp
;
467 lockdep_assert_held(&ar
->conf_mutex
);
469 spin_lock_bh(&ar
->data_lock
);
470 list_for_each_entry_safe(peer
, tmp
, &ar
->peers
, list
) {
471 list_del(&peer
->list
);
475 spin_unlock_bh(&ar
->data_lock
);
478 /************************/
479 /* Interface management */
480 /************************/
482 void ath10k_mac_vif_beacon_free(struct ath10k_vif
*arvif
)
484 struct ath10k
*ar
= arvif
->ar
;
486 lockdep_assert_held(&ar
->data_lock
);
491 if (!arvif
->beacon_buf
)
492 dma_unmap_single(ar
->dev
, ATH10K_SKB_CB(arvif
->beacon
)->paddr
,
493 arvif
->beacon
->len
, DMA_TO_DEVICE
);
495 dev_kfree_skb_any(arvif
->beacon
);
497 arvif
->beacon
= NULL
;
498 arvif
->beacon_sent
= false;
501 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif
*arvif
)
503 struct ath10k
*ar
= arvif
->ar
;
505 lockdep_assert_held(&ar
->data_lock
);
507 ath10k_mac_vif_beacon_free(arvif
);
509 if (arvif
->beacon_buf
) {
510 dma_free_coherent(ar
->dev
, IEEE80211_MAX_FRAME_LEN
,
511 arvif
->beacon_buf
, arvif
->beacon_paddr
);
512 arvif
->beacon_buf
= NULL
;
516 static inline int ath10k_vdev_setup_sync(struct ath10k
*ar
)
520 lockdep_assert_held(&ar
->conf_mutex
);
522 ret
= wait_for_completion_timeout(&ar
->vdev_setup_done
,
523 ATH10K_VDEV_SETUP_TIMEOUT_HZ
);
530 static int ath10k_monitor_vdev_start(struct ath10k
*ar
, int vdev_id
)
532 struct cfg80211_chan_def
*chandef
= &ar
->chandef
;
533 struct ieee80211_channel
*channel
= chandef
->chan
;
534 struct wmi_vdev_start_request_arg arg
= {};
537 lockdep_assert_held(&ar
->conf_mutex
);
539 arg
.vdev_id
= vdev_id
;
540 arg
.channel
.freq
= channel
->center_freq
;
541 arg
.channel
.band_center_freq1
= chandef
->center_freq1
;
543 /* TODO setup this dynamically, what in case we
544 don't have any vifs? */
545 arg
.channel
.mode
= chan_to_phymode(chandef
);
546 arg
.channel
.chan_radar
=
547 !!(channel
->flags
& IEEE80211_CHAN_RADAR
);
549 arg
.channel
.min_power
= 0;
550 arg
.channel
.max_power
= channel
->max_power
* 2;
551 arg
.channel
.max_reg_power
= channel
->max_reg_power
* 2;
552 arg
.channel
.max_antenna_gain
= channel
->max_antenna_gain
* 2;
554 ret
= ath10k_wmi_vdev_start(ar
, &arg
);
556 ath10k_warn(ar
, "failed to request monitor vdev %i start: %d\n",
561 ret
= ath10k_vdev_setup_sync(ar
);
563 ath10k_warn(ar
, "failed to synchronize setup for monitor vdev %i: %d\n",
568 ret
= ath10k_wmi_vdev_up(ar
, vdev_id
, 0, ar
->mac_addr
);
570 ath10k_warn(ar
, "failed to put up monitor vdev %i: %d\n",
575 ar
->monitor_vdev_id
= vdev_id
;
577 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %i started\n",
578 ar
->monitor_vdev_id
);
582 ret
= ath10k_wmi_vdev_stop(ar
, ar
->monitor_vdev_id
);
584 ath10k_warn(ar
, "failed to stop monitor vdev %i after start failure: %d\n",
585 ar
->monitor_vdev_id
, ret
);
590 static int ath10k_monitor_vdev_stop(struct ath10k
*ar
)
594 lockdep_assert_held(&ar
->conf_mutex
);
596 ret
= ath10k_wmi_vdev_down(ar
, ar
->monitor_vdev_id
);
598 ath10k_warn(ar
, "failed to put down monitor vdev %i: %d\n",
599 ar
->monitor_vdev_id
, ret
);
601 ret
= ath10k_wmi_vdev_stop(ar
, ar
->monitor_vdev_id
);
603 ath10k_warn(ar
, "failed to to request monitor vdev %i stop: %d\n",
604 ar
->monitor_vdev_id
, ret
);
606 ret
= ath10k_vdev_setup_sync(ar
);
608 ath10k_warn(ar
, "failed to synchronise monitor vdev %i: %d\n",
609 ar
->monitor_vdev_id
, ret
);
611 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %i stopped\n",
612 ar
->monitor_vdev_id
);
616 static int ath10k_monitor_vdev_create(struct ath10k
*ar
)
620 lockdep_assert_held(&ar
->conf_mutex
);
622 if (ar
->free_vdev_map
== 0) {
623 ath10k_warn(ar
, "failed to find free vdev id for monitor vdev\n");
627 bit
= __ffs64(ar
->free_vdev_map
);
629 ar
->monitor_vdev_id
= bit
;
631 ret
= ath10k_wmi_vdev_create(ar
, ar
->monitor_vdev_id
,
632 WMI_VDEV_TYPE_MONITOR
,
635 ath10k_warn(ar
, "failed to request monitor vdev %i creation: %d\n",
636 ar
->monitor_vdev_id
, ret
);
640 ar
->free_vdev_map
&= ~(1LL << ar
->monitor_vdev_id
);
641 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %d created\n",
642 ar
->monitor_vdev_id
);
647 static int ath10k_monitor_vdev_delete(struct ath10k
*ar
)
651 lockdep_assert_held(&ar
->conf_mutex
);
653 ret
= ath10k_wmi_vdev_delete(ar
, ar
->monitor_vdev_id
);
655 ath10k_warn(ar
, "failed to request wmi monitor vdev %i removal: %d\n",
656 ar
->monitor_vdev_id
, ret
);
660 ar
->free_vdev_map
|= 1LL << ar
->monitor_vdev_id
;
662 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %d deleted\n",
663 ar
->monitor_vdev_id
);
667 static int ath10k_monitor_start(struct ath10k
*ar
)
671 lockdep_assert_held(&ar
->conf_mutex
);
673 ret
= ath10k_monitor_vdev_create(ar
);
675 ath10k_warn(ar
, "failed to create monitor vdev: %d\n", ret
);
679 ret
= ath10k_monitor_vdev_start(ar
, ar
->monitor_vdev_id
);
681 ath10k_warn(ar
, "failed to start monitor vdev: %d\n", ret
);
682 ath10k_monitor_vdev_delete(ar
);
686 ar
->monitor_started
= true;
687 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor started\n");
692 static int ath10k_monitor_stop(struct ath10k
*ar
)
696 lockdep_assert_held(&ar
->conf_mutex
);
698 ret
= ath10k_monitor_vdev_stop(ar
);
700 ath10k_warn(ar
, "failed to stop monitor vdev: %d\n", ret
);
704 ret
= ath10k_monitor_vdev_delete(ar
);
706 ath10k_warn(ar
, "failed to delete monitor vdev: %d\n", ret
);
710 ar
->monitor_started
= false;
711 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor stopped\n");
716 static int ath10k_monitor_recalc(struct ath10k
*ar
)
720 lockdep_assert_held(&ar
->conf_mutex
);
722 should_start
= ar
->monitor
||
723 ar
->filter_flags
& FIF_PROMISC_IN_BSS
||
724 test_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
726 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
727 "mac monitor recalc started? %d should? %d\n",
728 ar
->monitor_started
, should_start
);
730 if (should_start
== ar
->monitor_started
)
734 return ath10k_monitor_start(ar
);
736 return ath10k_monitor_stop(ar
);
739 static int ath10k_recalc_rtscts_prot(struct ath10k_vif
*arvif
)
741 struct ath10k
*ar
= arvif
->ar
;
742 u32 vdev_param
, rts_cts
= 0;
744 lockdep_assert_held(&ar
->conf_mutex
);
746 vdev_param
= ar
->wmi
.vdev_param
->enable_rtscts
;
748 if (arvif
->use_cts_prot
|| arvif
->num_legacy_stations
> 0)
749 rts_cts
|= SM(WMI_RTSCTS_ENABLED
, WMI_RTSCTS_SET
);
751 if (arvif
->num_legacy_stations
> 0)
752 rts_cts
|= SM(WMI_RTSCTS_ACROSS_SW_RETRIES
,
755 return ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
759 static int ath10k_start_cac(struct ath10k
*ar
)
763 lockdep_assert_held(&ar
->conf_mutex
);
765 set_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
767 ret
= ath10k_monitor_recalc(ar
);
769 ath10k_warn(ar
, "failed to start monitor (cac): %d\n", ret
);
770 clear_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
774 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac cac start monitor vdev %d\n",
775 ar
->monitor_vdev_id
);
780 static int ath10k_stop_cac(struct ath10k
*ar
)
782 lockdep_assert_held(&ar
->conf_mutex
);
784 /* CAC is not running - do nothing */
785 if (!test_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
))
788 clear_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
789 ath10k_monitor_stop(ar
);
791 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac cac finished\n");
796 static void ath10k_recalc_radar_detection(struct ath10k
*ar
)
800 lockdep_assert_held(&ar
->conf_mutex
);
804 if (!ar
->radar_enabled
)
807 if (ar
->num_started_vdevs
> 0)
810 ret
= ath10k_start_cac(ar
);
813 * Not possible to start CAC on current channel so starting
814 * radiation is not allowed, make this channel DFS_UNAVAILABLE
815 * by indicating that radar was detected.
817 ath10k_warn(ar
, "failed to start CAC: %d\n", ret
);
818 ieee80211_radar_detected(ar
->hw
);
822 static int ath10k_vdev_start_restart(struct ath10k_vif
*arvif
, bool restart
)
824 struct ath10k
*ar
= arvif
->ar
;
825 struct cfg80211_chan_def
*chandef
= &ar
->chandef
;
826 struct wmi_vdev_start_request_arg arg
= {};
829 lockdep_assert_held(&ar
->conf_mutex
);
831 reinit_completion(&ar
->vdev_setup_done
);
833 arg
.vdev_id
= arvif
->vdev_id
;
834 arg
.dtim_period
= arvif
->dtim_period
;
835 arg
.bcn_intval
= arvif
->beacon_interval
;
837 arg
.channel
.freq
= chandef
->chan
->center_freq
;
838 arg
.channel
.band_center_freq1
= chandef
->center_freq1
;
839 arg
.channel
.mode
= chan_to_phymode(chandef
);
841 arg
.channel
.min_power
= 0;
842 arg
.channel
.max_power
= chandef
->chan
->max_power
* 2;
843 arg
.channel
.max_reg_power
= chandef
->chan
->max_reg_power
* 2;
844 arg
.channel
.max_antenna_gain
= chandef
->chan
->max_antenna_gain
* 2;
846 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
) {
847 arg
.ssid
= arvif
->u
.ap
.ssid
;
848 arg
.ssid_len
= arvif
->u
.ap
.ssid_len
;
849 arg
.hidden_ssid
= arvif
->u
.ap
.hidden_ssid
;
851 /* For now allow DFS for AP mode */
852 arg
.channel
.chan_radar
=
853 !!(chandef
->chan
->flags
& IEEE80211_CHAN_RADAR
);
854 } else if (arvif
->vdev_type
== WMI_VDEV_TYPE_IBSS
) {
855 arg
.ssid
= arvif
->vif
->bss_conf
.ssid
;
856 arg
.ssid_len
= arvif
->vif
->bss_conf
.ssid_len
;
859 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
860 "mac vdev %d start center_freq %d phymode %s\n",
861 arg
.vdev_id
, arg
.channel
.freq
,
862 ath10k_wmi_phymode_str(arg
.channel
.mode
));
865 ret
= ath10k_wmi_vdev_restart(ar
, &arg
);
867 ret
= ath10k_wmi_vdev_start(ar
, &arg
);
870 ath10k_warn(ar
, "failed to start WMI vdev %i: %d\n",
875 ret
= ath10k_vdev_setup_sync(ar
);
877 ath10k_warn(ar
, "failed to synchronise setup for vdev %i: %d\n",
882 ar
->num_started_vdevs
++;
883 ath10k_recalc_radar_detection(ar
);
888 static int ath10k_vdev_start(struct ath10k_vif
*arvif
)
890 return ath10k_vdev_start_restart(arvif
, false);
893 static int ath10k_vdev_restart(struct ath10k_vif
*arvif
)
895 return ath10k_vdev_start_restart(arvif
, true);
898 static int ath10k_vdev_stop(struct ath10k_vif
*arvif
)
900 struct ath10k
*ar
= arvif
->ar
;
903 lockdep_assert_held(&ar
->conf_mutex
);
905 reinit_completion(&ar
->vdev_setup_done
);
907 ret
= ath10k_wmi_vdev_stop(ar
, arvif
->vdev_id
);
909 ath10k_warn(ar
, "failed to stop WMI vdev %i: %d\n",
910 arvif
->vdev_id
, ret
);
914 ret
= ath10k_vdev_setup_sync(ar
);
916 ath10k_warn(ar
, "failed to syncronise setup for vdev %i: %d\n",
917 arvif
->vdev_id
, ret
);
921 WARN_ON(ar
->num_started_vdevs
== 0);
923 if (ar
->num_started_vdevs
!= 0) {
924 ar
->num_started_vdevs
--;
925 ath10k_recalc_radar_detection(ar
);
931 static void ath10k_control_beaconing(struct ath10k_vif
*arvif
,
932 struct ieee80211_bss_conf
*info
)
934 struct ath10k
*ar
= arvif
->ar
;
937 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
939 if (!info
->enable_beacon
) {
940 ath10k_vdev_stop(arvif
);
942 arvif
->is_started
= false;
943 arvif
->is_up
= false;
945 spin_lock_bh(&arvif
->ar
->data_lock
);
946 ath10k_mac_vif_beacon_free(arvif
);
947 spin_unlock_bh(&arvif
->ar
->data_lock
);
952 arvif
->tx_seq_no
= 0x1000;
954 ret
= ath10k_vdev_start(arvif
);
959 ether_addr_copy(arvif
->bssid
, info
->bssid
);
961 ret
= ath10k_wmi_vdev_up(arvif
->ar
, arvif
->vdev_id
, arvif
->aid
,
964 ath10k_warn(ar
, "failed to bring up vdev %d: %i\n",
965 arvif
->vdev_id
, ret
);
966 ath10k_vdev_stop(arvif
);
970 arvif
->is_started
= true;
973 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d up\n", arvif
->vdev_id
);
976 static void ath10k_control_ibss(struct ath10k_vif
*arvif
,
977 struct ieee80211_bss_conf
*info
,
978 const u8 self_peer
[ETH_ALEN
])
980 struct ath10k
*ar
= arvif
->ar
;
984 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
986 if (!info
->ibss_joined
) {
987 ret
= ath10k_peer_delete(arvif
->ar
, arvif
->vdev_id
, self_peer
);
989 ath10k_warn(ar
, "failed to delete IBSS self peer %pM for vdev %d: %d\n",
990 self_peer
, arvif
->vdev_id
, ret
);
992 if (is_zero_ether_addr(arvif
->bssid
))
995 memset(arvif
->bssid
, 0, ETH_ALEN
);
1000 ret
= ath10k_peer_create(arvif
->ar
, arvif
->vdev_id
, self_peer
);
1002 ath10k_warn(ar
, "failed to create IBSS self peer %pM for vdev %d: %d\n",
1003 self_peer
, arvif
->vdev_id
, ret
);
1007 vdev_param
= arvif
->ar
->wmi
.vdev_param
->atim_window
;
1008 ret
= ath10k_wmi_vdev_set_param(arvif
->ar
, arvif
->vdev_id
, vdev_param
,
1009 ATH10K_DEFAULT_ATIM
);
1011 ath10k_warn(ar
, "failed to set IBSS ATIM for vdev %d: %d\n",
1012 arvif
->vdev_id
, ret
);
1016 * Review this when mac80211 gains per-interface powersave support.
1018 static int ath10k_mac_vif_setup_ps(struct ath10k_vif
*arvif
)
1020 struct ath10k
*ar
= arvif
->ar
;
1021 struct ieee80211_conf
*conf
= &ar
->hw
->conf
;
1022 enum wmi_sta_powersave_param param
;
1023 enum wmi_sta_ps_mode psmode
;
1026 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1028 if (arvif
->vif
->type
!= NL80211_IFTYPE_STATION
)
1031 if (conf
->flags
& IEEE80211_CONF_PS
) {
1032 psmode
= WMI_STA_PS_MODE_ENABLED
;
1033 param
= WMI_STA_PS_PARAM_INACTIVITY_TIME
;
1035 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
, param
,
1036 conf
->dynamic_ps_timeout
);
1038 ath10k_warn(ar
, "failed to set inactivity time for vdev %d: %i\n",
1039 arvif
->vdev_id
, ret
);
1043 psmode
= WMI_STA_PS_MODE_DISABLED
;
1046 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d psmode %s\n",
1047 arvif
->vdev_id
, psmode
? "enable" : "disable");
1049 ret
= ath10k_wmi_set_psmode(ar
, arvif
->vdev_id
, psmode
);
1051 ath10k_warn(ar
, "failed to set PS Mode %d for vdev %d: %d\n",
1052 psmode
, arvif
->vdev_id
, ret
);
1059 /**********************/
1060 /* Station management */
1061 /**********************/
1063 static u32
ath10k_peer_assoc_h_listen_intval(struct ath10k
*ar
,
1064 struct ieee80211_vif
*vif
)
1066 /* Some firmware revisions have unstable STA powersave when listen
1067 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1068 * generate NullFunc frames properly even if buffered frames have been
1069 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1070 * buffered frames. Often pinging the device from AP would simply fail.
1072 * As a workaround set it to 1.
1074 if (vif
->type
== NL80211_IFTYPE_STATION
)
1077 return ar
->hw
->conf
.listen_interval
;
1080 static void ath10k_peer_assoc_h_basic(struct ath10k
*ar
,
1081 struct ieee80211_vif
*vif
,
1082 struct ieee80211_sta
*sta
,
1083 struct wmi_peer_assoc_complete_arg
*arg
)
1085 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1087 lockdep_assert_held(&ar
->conf_mutex
);
1089 ether_addr_copy(arg
->addr
, sta
->addr
);
1090 arg
->vdev_id
= arvif
->vdev_id
;
1091 arg
->peer_aid
= sta
->aid
;
1092 arg
->peer_flags
|= WMI_PEER_AUTH
;
1093 arg
->peer_listen_intval
= ath10k_peer_assoc_h_listen_intval(ar
, vif
);
1094 arg
->peer_num_spatial_streams
= 1;
1095 arg
->peer_caps
= vif
->bss_conf
.assoc_capability
;
1098 static void ath10k_peer_assoc_h_crypto(struct ath10k
*ar
,
1099 struct ieee80211_vif
*vif
,
1100 struct wmi_peer_assoc_complete_arg
*arg
)
1102 struct ieee80211_bss_conf
*info
= &vif
->bss_conf
;
1103 struct cfg80211_bss
*bss
;
1104 const u8
*rsnie
= NULL
;
1105 const u8
*wpaie
= NULL
;
1107 lockdep_assert_held(&ar
->conf_mutex
);
1109 bss
= cfg80211_get_bss(ar
->hw
->wiphy
, ar
->hw
->conf
.chandef
.chan
,
1110 info
->bssid
, NULL
, 0, 0, 0);
1112 const struct cfg80211_bss_ies
*ies
;
1115 rsnie
= ieee80211_bss_get_ie(bss
, WLAN_EID_RSN
);
1117 ies
= rcu_dereference(bss
->ies
);
1119 wpaie
= cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT
,
1120 WLAN_OUI_TYPE_MICROSOFT_WPA
,
1124 cfg80211_put_bss(ar
->hw
->wiphy
, bss
);
1127 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1128 if (rsnie
|| wpaie
) {
1129 ath10k_dbg(ar
, ATH10K_DBG_WMI
, "%s: rsn ie found\n", __func__
);
1130 arg
->peer_flags
|= WMI_PEER_NEED_PTK_4_WAY
;
1134 ath10k_dbg(ar
, ATH10K_DBG_WMI
, "%s: wpa ie found\n", __func__
);
1135 arg
->peer_flags
|= WMI_PEER_NEED_GTK_2_WAY
;
1139 static void ath10k_peer_assoc_h_rates(struct ath10k
*ar
,
1140 struct ieee80211_sta
*sta
,
1141 struct wmi_peer_assoc_complete_arg
*arg
)
1143 struct wmi_rate_set_arg
*rateset
= &arg
->peer_legacy_rates
;
1144 const struct ieee80211_supported_band
*sband
;
1145 const struct ieee80211_rate
*rates
;
1149 lockdep_assert_held(&ar
->conf_mutex
);
1151 sband
= ar
->hw
->wiphy
->bands
[ar
->hw
->conf
.chandef
.chan
->band
];
1152 ratemask
= sta
->supp_rates
[ar
->hw
->conf
.chandef
.chan
->band
];
1153 rates
= sband
->bitrates
;
1155 rateset
->num_rates
= 0;
1157 for (i
= 0; i
< 32; i
++, ratemask
>>= 1, rates
++) {
1158 if (!(ratemask
& 1))
1161 rateset
->rates
[rateset
->num_rates
] = rates
->hw_value
;
1162 rateset
->num_rates
++;
1166 static void ath10k_peer_assoc_h_ht(struct ath10k
*ar
,
1167 struct ieee80211_sta
*sta
,
1168 struct wmi_peer_assoc_complete_arg
*arg
)
1170 const struct ieee80211_sta_ht_cap
*ht_cap
= &sta
->ht_cap
;
1174 lockdep_assert_held(&ar
->conf_mutex
);
1176 if (!ht_cap
->ht_supported
)
1179 arg
->peer_flags
|= WMI_PEER_HT
;
1180 arg
->peer_max_mpdu
= (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR
+
1181 ht_cap
->ampdu_factor
)) - 1;
1183 arg
->peer_mpdu_density
=
1184 ath10k_parse_mpdudensity(ht_cap
->ampdu_density
);
1186 arg
->peer_ht_caps
= ht_cap
->cap
;
1187 arg
->peer_rate_caps
|= WMI_RC_HT_FLAG
;
1189 if (ht_cap
->cap
& IEEE80211_HT_CAP_LDPC_CODING
)
1190 arg
->peer_flags
|= WMI_PEER_LDPC
;
1192 if (sta
->bandwidth
>= IEEE80211_STA_RX_BW_40
) {
1193 arg
->peer_flags
|= WMI_PEER_40MHZ
;
1194 arg
->peer_rate_caps
|= WMI_RC_CW40_FLAG
;
1197 if (ht_cap
->cap
& IEEE80211_HT_CAP_SGI_20
)
1198 arg
->peer_rate_caps
|= WMI_RC_SGI_FLAG
;
1200 if (ht_cap
->cap
& IEEE80211_HT_CAP_SGI_40
)
1201 arg
->peer_rate_caps
|= WMI_RC_SGI_FLAG
;
1203 if (ht_cap
->cap
& IEEE80211_HT_CAP_TX_STBC
) {
1204 arg
->peer_rate_caps
|= WMI_RC_TX_STBC_FLAG
;
1205 arg
->peer_flags
|= WMI_PEER_STBC
;
1208 if (ht_cap
->cap
& IEEE80211_HT_CAP_RX_STBC
) {
1209 stbc
= ht_cap
->cap
& IEEE80211_HT_CAP_RX_STBC
;
1210 stbc
= stbc
>> IEEE80211_HT_CAP_RX_STBC_SHIFT
;
1211 stbc
= stbc
<< WMI_RC_RX_STBC_FLAG_S
;
1212 arg
->peer_rate_caps
|= stbc
;
1213 arg
->peer_flags
|= WMI_PEER_STBC
;
1216 if (ht_cap
->mcs
.rx_mask
[1] && ht_cap
->mcs
.rx_mask
[2])
1217 arg
->peer_rate_caps
|= WMI_RC_TS_FLAG
;
1218 else if (ht_cap
->mcs
.rx_mask
[1])
1219 arg
->peer_rate_caps
|= WMI_RC_DS_FLAG
;
1221 for (i
= 0, n
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
*8; i
++)
1222 if (ht_cap
->mcs
.rx_mask
[i
/8] & (1 << i
%8))
1223 arg
->peer_ht_rates
.rates
[n
++] = i
;
1226 * This is a workaround for HT-enabled STAs which break the spec
1227 * and have no HT capabilities RX mask (no HT RX MCS map).
1229 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1230 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1232 * Firmware asserts if such situation occurs.
1235 arg
->peer_ht_rates
.num_rates
= 8;
1236 for (i
= 0; i
< arg
->peer_ht_rates
.num_rates
; i
++)
1237 arg
->peer_ht_rates
.rates
[i
] = i
;
1239 arg
->peer_ht_rates
.num_rates
= n
;
1240 arg
->peer_num_spatial_streams
= sta
->rx_nss
;
1243 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac ht peer %pM mcs cnt %d nss %d\n",
1245 arg
->peer_ht_rates
.num_rates
,
1246 arg
->peer_num_spatial_streams
);
1249 static int ath10k_peer_assoc_qos_ap(struct ath10k
*ar
,
1250 struct ath10k_vif
*arvif
,
1251 struct ieee80211_sta
*sta
)
1257 lockdep_assert_held(&ar
->conf_mutex
);
1259 if (sta
->wme
&& sta
->uapsd_queues
) {
1260 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac uapsd_queues 0x%x max_sp %d\n",
1261 sta
->uapsd_queues
, sta
->max_sp
);
1263 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_VO
)
1264 uapsd
|= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN
|
1265 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN
;
1266 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_VI
)
1267 uapsd
|= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN
|
1268 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN
;
1269 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
)
1270 uapsd
|= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN
|
1271 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN
;
1272 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_BE
)
1273 uapsd
|= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN
|
1274 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN
;
1276 if (sta
->max_sp
< MAX_WMI_AP_PS_PEER_PARAM_MAX_SP
)
1277 max_sp
= sta
->max_sp
;
1279 ret
= ath10k_wmi_set_ap_ps_param(ar
, arvif
->vdev_id
,
1281 WMI_AP_PS_PEER_PARAM_UAPSD
,
1284 ath10k_warn(ar
, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
1285 arvif
->vdev_id
, ret
);
1289 ret
= ath10k_wmi_set_ap_ps_param(ar
, arvif
->vdev_id
,
1291 WMI_AP_PS_PEER_PARAM_MAX_SP
,
1294 ath10k_warn(ar
, "failed to set ap ps peer param max sp for vdev %i: %d\n",
1295 arvif
->vdev_id
, ret
);
1299 /* TODO setup this based on STA listen interval and
1300 beacon interval. Currently we don't know
1301 sta->listen_interval - mac80211 patch required.
1302 Currently use 10 seconds */
1303 ret
= ath10k_wmi_set_ap_ps_param(ar
, arvif
->vdev_id
, sta
->addr
,
1304 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME
,
1307 ath10k_warn(ar
, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
1308 arvif
->vdev_id
, ret
);
1316 static void ath10k_peer_assoc_h_vht(struct ath10k
*ar
,
1317 struct ieee80211_sta
*sta
,
1318 struct wmi_peer_assoc_complete_arg
*arg
)
1320 const struct ieee80211_sta_vht_cap
*vht_cap
= &sta
->vht_cap
;
1323 if (!vht_cap
->vht_supported
)
1326 arg
->peer_flags
|= WMI_PEER_VHT
;
1327 arg
->peer_vht_caps
= vht_cap
->cap
;
1329 ampdu_factor
= (vht_cap
->cap
&
1330 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK
) >>
1331 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT
;
1333 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1334 * zero in VHT IE. Using it would result in degraded throughput.
1335 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1336 * it if VHT max_mpdu is smaller. */
1337 arg
->peer_max_mpdu
= max(arg
->peer_max_mpdu
,
1338 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR
+
1339 ampdu_factor
)) - 1);
1341 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_80
)
1342 arg
->peer_flags
|= WMI_PEER_80MHZ
;
1344 arg
->peer_vht_rates
.rx_max_rate
=
1345 __le16_to_cpu(vht_cap
->vht_mcs
.rx_highest
);
1346 arg
->peer_vht_rates
.rx_mcs_set
=
1347 __le16_to_cpu(vht_cap
->vht_mcs
.rx_mcs_map
);
1348 arg
->peer_vht_rates
.tx_max_rate
=
1349 __le16_to_cpu(vht_cap
->vht_mcs
.tx_highest
);
1350 arg
->peer_vht_rates
.tx_mcs_set
=
1351 __le16_to_cpu(vht_cap
->vht_mcs
.tx_mcs_map
);
1353 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1354 sta
->addr
, arg
->peer_max_mpdu
, arg
->peer_flags
);
1357 static void ath10k_peer_assoc_h_qos(struct ath10k
*ar
,
1358 struct ieee80211_vif
*vif
,
1359 struct ieee80211_sta
*sta
,
1360 struct wmi_peer_assoc_complete_arg
*arg
)
1362 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1364 switch (arvif
->vdev_type
) {
1365 case WMI_VDEV_TYPE_AP
:
1367 arg
->peer_flags
|= WMI_PEER_QOS
;
1369 if (sta
->wme
&& sta
->uapsd_queues
) {
1370 arg
->peer_flags
|= WMI_PEER_APSD
;
1371 arg
->peer_rate_caps
|= WMI_RC_UAPSD_FLAG
;
1374 case WMI_VDEV_TYPE_STA
:
1375 if (vif
->bss_conf
.qos
)
1376 arg
->peer_flags
|= WMI_PEER_QOS
;
1383 static void ath10k_peer_assoc_h_phymode(struct ath10k
*ar
,
1384 struct ieee80211_vif
*vif
,
1385 struct ieee80211_sta
*sta
,
1386 struct wmi_peer_assoc_complete_arg
*arg
)
1388 enum wmi_phy_mode phymode
= MODE_UNKNOWN
;
1390 switch (ar
->hw
->conf
.chandef
.chan
->band
) {
1391 case IEEE80211_BAND_2GHZ
:
1392 if (sta
->ht_cap
.ht_supported
) {
1393 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_40
)
1394 phymode
= MODE_11NG_HT40
;
1396 phymode
= MODE_11NG_HT20
;
1402 case IEEE80211_BAND_5GHZ
:
1406 if (sta
->vht_cap
.vht_supported
) {
1407 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_80
)
1408 phymode
= MODE_11AC_VHT80
;
1409 else if (sta
->bandwidth
== IEEE80211_STA_RX_BW_40
)
1410 phymode
= MODE_11AC_VHT40
;
1411 else if (sta
->bandwidth
== IEEE80211_STA_RX_BW_20
)
1412 phymode
= MODE_11AC_VHT20
;
1413 } else if (sta
->ht_cap
.ht_supported
) {
1414 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_40
)
1415 phymode
= MODE_11NA_HT40
;
1417 phymode
= MODE_11NA_HT20
;
1427 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac peer %pM phymode %s\n",
1428 sta
->addr
, ath10k_wmi_phymode_str(phymode
));
1430 arg
->peer_phymode
= phymode
;
1431 WARN_ON(phymode
== MODE_UNKNOWN
);
1434 static int ath10k_peer_assoc_prepare(struct ath10k
*ar
,
1435 struct ieee80211_vif
*vif
,
1436 struct ieee80211_sta
*sta
,
1437 struct wmi_peer_assoc_complete_arg
*arg
)
1439 lockdep_assert_held(&ar
->conf_mutex
);
1441 memset(arg
, 0, sizeof(*arg
));
1443 ath10k_peer_assoc_h_basic(ar
, vif
, sta
, arg
);
1444 ath10k_peer_assoc_h_crypto(ar
, vif
, arg
);
1445 ath10k_peer_assoc_h_rates(ar
, sta
, arg
);
1446 ath10k_peer_assoc_h_ht(ar
, sta
, arg
);
1447 ath10k_peer_assoc_h_vht(ar
, sta
, arg
);
1448 ath10k_peer_assoc_h_qos(ar
, vif
, sta
, arg
);
1449 ath10k_peer_assoc_h_phymode(ar
, vif
, sta
, arg
);
1454 static const u32 ath10k_smps_map
[] = {
1455 [WLAN_HT_CAP_SM_PS_STATIC
] = WMI_PEER_SMPS_STATIC
,
1456 [WLAN_HT_CAP_SM_PS_DYNAMIC
] = WMI_PEER_SMPS_DYNAMIC
,
1457 [WLAN_HT_CAP_SM_PS_INVALID
] = WMI_PEER_SMPS_PS_NONE
,
1458 [WLAN_HT_CAP_SM_PS_DISABLED
] = WMI_PEER_SMPS_PS_NONE
,
1461 static int ath10k_setup_peer_smps(struct ath10k
*ar
, struct ath10k_vif
*arvif
,
1463 const struct ieee80211_sta_ht_cap
*ht_cap
)
1467 if (!ht_cap
->ht_supported
)
1470 smps
= ht_cap
->cap
& IEEE80211_HT_CAP_SM_PS
;
1471 smps
>>= IEEE80211_HT_CAP_SM_PS_SHIFT
;
1473 if (smps
>= ARRAY_SIZE(ath10k_smps_map
))
1476 return ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, addr
,
1477 WMI_PEER_SMPS_STATE
,
1478 ath10k_smps_map
[smps
]);
1481 /* can be called only in mac80211 callbacks due to `key_count` usage */
1482 static void ath10k_bss_assoc(struct ieee80211_hw
*hw
,
1483 struct ieee80211_vif
*vif
,
1484 struct ieee80211_bss_conf
*bss_conf
)
1486 struct ath10k
*ar
= hw
->priv
;
1487 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1488 struct ieee80211_sta_ht_cap ht_cap
;
1489 struct wmi_peer_assoc_complete_arg peer_arg
;
1490 struct ieee80211_sta
*ap_sta
;
1493 lockdep_assert_held(&ar
->conf_mutex
);
1497 ap_sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
1499 ath10k_warn(ar
, "failed to find station entry for bss %pM vdev %i\n",
1500 bss_conf
->bssid
, arvif
->vdev_id
);
1505 /* ap_sta must be accessed only within rcu section which must be left
1506 * before calling ath10k_setup_peer_smps() which might sleep. */
1507 ht_cap
= ap_sta
->ht_cap
;
1509 ret
= ath10k_peer_assoc_prepare(ar
, vif
, ap_sta
, &peer_arg
);
1511 ath10k_warn(ar
, "failed to prepare peer assoc for %pM vdev %i: %d\n",
1512 bss_conf
->bssid
, arvif
->vdev_id
, ret
);
1519 ret
= ath10k_wmi_peer_assoc(ar
, &peer_arg
);
1521 ath10k_warn(ar
, "failed to run peer assoc for %pM vdev %i: %d\n",
1522 bss_conf
->bssid
, arvif
->vdev_id
, ret
);
1526 ret
= ath10k_setup_peer_smps(ar
, arvif
, bss_conf
->bssid
, &ht_cap
);
1528 ath10k_warn(ar
, "failed to setup peer SMPS for vdev %i: %d\n",
1529 arvif
->vdev_id
, ret
);
1533 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
1534 "mac vdev %d up (associated) bssid %pM aid %d\n",
1535 arvif
->vdev_id
, bss_conf
->bssid
, bss_conf
->aid
);
1537 arvif
->aid
= bss_conf
->aid
;
1538 ether_addr_copy(arvif
->bssid
, bss_conf
->bssid
);
1540 ret
= ath10k_wmi_vdev_up(ar
, arvif
->vdev_id
, arvif
->aid
, arvif
->bssid
);
1542 ath10k_warn(ar
, "failed to set vdev %d up: %d\n",
1543 arvif
->vdev_id
, ret
);
1547 arvif
->is_up
= true;
1553 static void ath10k_bss_disassoc(struct ieee80211_hw
*hw
,
1554 struct ieee80211_vif
*vif
)
1556 struct ath10k
*ar
= hw
->priv
;
1557 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1560 lockdep_assert_held(&ar
->conf_mutex
);
1563 * For some reason, calling VDEV-DOWN before VDEV-STOP
1564 * makes the FW to send frames via HTT after disassociation.
1565 * No idea why this happens, even though VDEV-DOWN is supposed
1566 * to be analogous to link down, so just stop the VDEV.
1568 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d stop (disassociated\n",
1571 /* FIXME: check return value */
1572 ret
= ath10k_vdev_stop(arvif
);
1575 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1576 * report beacons from previously associated network through HTT.
1577 * This in turn would spam mac80211 WARN_ON if we bring down all
1578 * interfaces as it expects there is no rx when no interface is
1581 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d down\n", arvif
->vdev_id
);
1583 /* FIXME: why don't we print error if wmi call fails? */
1584 ret
= ath10k_wmi_vdev_down(ar
, arvif
->vdev_id
);
1586 arvif
->def_wep_key_idx
= 0;
1588 arvif
->is_started
= false;
1589 arvif
->is_up
= false;
1592 static int ath10k_station_assoc(struct ath10k
*ar
,
1593 struct ieee80211_vif
*vif
,
1594 struct ieee80211_sta
*sta
,
1597 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1598 struct wmi_peer_assoc_complete_arg peer_arg
;
1601 lockdep_assert_held(&ar
->conf_mutex
);
1603 ret
= ath10k_peer_assoc_prepare(ar
, vif
, sta
, &peer_arg
);
1605 ath10k_warn(ar
, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1606 sta
->addr
, arvif
->vdev_id
, ret
);
1610 peer_arg
.peer_reassoc
= reassoc
;
1611 ret
= ath10k_wmi_peer_assoc(ar
, &peer_arg
);
1613 ath10k_warn(ar
, "failed to run peer assoc for STA %pM vdev %i: %d\n",
1614 sta
->addr
, arvif
->vdev_id
, ret
);
1618 ret
= ath10k_setup_peer_smps(ar
, arvif
, sta
->addr
, &sta
->ht_cap
);
1620 ath10k_warn(ar
, "failed to setup peer SMPS for vdev %d: %d\n",
1621 arvif
->vdev_id
, ret
);
1625 if (!sta
->wme
&& !reassoc
) {
1626 arvif
->num_legacy_stations
++;
1627 ret
= ath10k_recalc_rtscts_prot(arvif
);
1629 ath10k_warn(ar
, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1630 arvif
->vdev_id
, ret
);
1635 ret
= ath10k_install_peer_wep_keys(arvif
, sta
->addr
);
1637 ath10k_warn(ar
, "failed to install peer wep keys for vdev %i: %d\n",
1638 arvif
->vdev_id
, ret
);
1642 ret
= ath10k_peer_assoc_qos_ap(ar
, arvif
, sta
);
1644 ath10k_warn(ar
, "failed to set qos params for STA %pM for vdev %i: %d\n",
1645 sta
->addr
, arvif
->vdev_id
, ret
);
1652 static int ath10k_station_disassoc(struct ath10k
*ar
,
1653 struct ieee80211_vif
*vif
,
1654 struct ieee80211_sta
*sta
)
1656 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1659 lockdep_assert_held(&ar
->conf_mutex
);
1662 arvif
->num_legacy_stations
--;
1663 ret
= ath10k_recalc_rtscts_prot(arvif
);
1665 ath10k_warn(ar
, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1666 arvif
->vdev_id
, ret
);
1671 ret
= ath10k_clear_peer_keys(arvif
, sta
->addr
);
1673 ath10k_warn(ar
, "failed to clear all peer wep keys for vdev %i: %d\n",
1674 arvif
->vdev_id
, ret
);
1685 static int ath10k_update_channel_list(struct ath10k
*ar
)
1687 struct ieee80211_hw
*hw
= ar
->hw
;
1688 struct ieee80211_supported_band
**bands
;
1689 enum ieee80211_band band
;
1690 struct ieee80211_channel
*channel
;
1691 struct wmi_scan_chan_list_arg arg
= {0};
1692 struct wmi_channel_arg
*ch
;
1698 lockdep_assert_held(&ar
->conf_mutex
);
1700 bands
= hw
->wiphy
->bands
;
1701 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
1705 for (i
= 0; i
< bands
[band
]->n_channels
; i
++) {
1706 if (bands
[band
]->channels
[i
].flags
&
1707 IEEE80211_CHAN_DISABLED
)
1714 len
= sizeof(struct wmi_channel_arg
) * arg
.n_channels
;
1715 arg
.channels
= kzalloc(len
, GFP_KERNEL
);
1720 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
1724 for (i
= 0; i
< bands
[band
]->n_channels
; i
++) {
1725 channel
= &bands
[band
]->channels
[i
];
1727 if (channel
->flags
& IEEE80211_CHAN_DISABLED
)
1730 ch
->allow_ht
= true;
1732 /* FIXME: when should we really allow VHT? */
1733 ch
->allow_vht
= true;
1736 !(channel
->flags
& IEEE80211_CHAN_NO_IR
);
1739 !(channel
->flags
& IEEE80211_CHAN_NO_HT40PLUS
);
1742 !!(channel
->flags
& IEEE80211_CHAN_RADAR
);
1744 passive
= channel
->flags
& IEEE80211_CHAN_NO_IR
;
1745 ch
->passive
= passive
;
1747 ch
->freq
= channel
->center_freq
;
1748 ch
->band_center_freq1
= channel
->center_freq
;
1750 ch
->max_power
= channel
->max_power
* 2;
1751 ch
->max_reg_power
= channel
->max_reg_power
* 2;
1752 ch
->max_antenna_gain
= channel
->max_antenna_gain
* 2;
1753 ch
->reg_class_id
= 0; /* FIXME */
1755 /* FIXME: why use only legacy modes, why not any
1756 * HT/VHT modes? Would that even make any
1758 if (channel
->band
== IEEE80211_BAND_2GHZ
)
1759 ch
->mode
= MODE_11G
;
1761 ch
->mode
= MODE_11A
;
1763 if (WARN_ON_ONCE(ch
->mode
== MODE_UNKNOWN
))
1766 ath10k_dbg(ar
, ATH10K_DBG_WMI
,
1767 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1768 ch
- arg
.channels
, arg
.n_channels
,
1769 ch
->freq
, ch
->max_power
, ch
->max_reg_power
,
1770 ch
->max_antenna_gain
, ch
->mode
);
1776 ret
= ath10k_wmi_scan_chan_list(ar
, &arg
);
1777 kfree(arg
.channels
);
1782 static enum wmi_dfs_region
1783 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region
)
1785 switch (dfs_region
) {
1786 case NL80211_DFS_UNSET
:
1787 return WMI_UNINIT_DFS_DOMAIN
;
1788 case NL80211_DFS_FCC
:
1789 return WMI_FCC_DFS_DOMAIN
;
1790 case NL80211_DFS_ETSI
:
1791 return WMI_ETSI_DFS_DOMAIN
;
1792 case NL80211_DFS_JP
:
1793 return WMI_MKK4_DFS_DOMAIN
;
1795 return WMI_UNINIT_DFS_DOMAIN
;
1798 static void ath10k_regd_update(struct ath10k
*ar
)
1800 struct reg_dmn_pair_mapping
*regpair
;
1802 enum wmi_dfs_region wmi_dfs_reg
;
1803 enum nl80211_dfs_regions nl_dfs_reg
;
1805 lockdep_assert_held(&ar
->conf_mutex
);
1807 ret
= ath10k_update_channel_list(ar
);
1809 ath10k_warn(ar
, "failed to update channel list: %d\n", ret
);
1811 regpair
= ar
->ath_common
.regulatory
.regpair
;
1813 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
) && ar
->dfs_detector
) {
1814 nl_dfs_reg
= ar
->dfs_detector
->region
;
1815 wmi_dfs_reg
= ath10k_mac_get_dfs_region(nl_dfs_reg
);
1817 wmi_dfs_reg
= WMI_UNINIT_DFS_DOMAIN
;
1820 /* Target allows setting up per-band regdomain but ath_common provides
1821 * a combined one only */
1822 ret
= ath10k_wmi_pdev_set_regdomain(ar
,
1823 regpair
->reg_domain
,
1824 regpair
->reg_domain
, /* 2ghz */
1825 regpair
->reg_domain
, /* 5ghz */
1826 regpair
->reg_2ghz_ctl
,
1827 regpair
->reg_5ghz_ctl
,
1830 ath10k_warn(ar
, "failed to set pdev regdomain: %d\n", ret
);
1833 static void ath10k_reg_notifier(struct wiphy
*wiphy
,
1834 struct regulatory_request
*request
)
1836 struct ieee80211_hw
*hw
= wiphy_to_ieee80211_hw(wiphy
);
1837 struct ath10k
*ar
= hw
->priv
;
1840 ath_reg_notifier_apply(wiphy
, request
, &ar
->ath_common
.regulatory
);
1842 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
) && ar
->dfs_detector
) {
1843 ath10k_dbg(ar
, ATH10K_DBG_REGULATORY
, "dfs region 0x%x\n",
1844 request
->dfs_region
);
1845 result
= ar
->dfs_detector
->set_dfs_domain(ar
->dfs_detector
,
1846 request
->dfs_region
);
1848 ath10k_warn(ar
, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
1849 request
->dfs_region
);
1852 mutex_lock(&ar
->conf_mutex
);
1853 if (ar
->state
== ATH10K_STATE_ON
)
1854 ath10k_regd_update(ar
);
1855 mutex_unlock(&ar
->conf_mutex
);
1862 static u8
ath10k_tx_h_get_tid(struct ieee80211_hdr
*hdr
)
1864 if (ieee80211_is_mgmt(hdr
->frame_control
))
1865 return HTT_DATA_TX_EXT_TID_MGMT
;
1867 if (!ieee80211_is_data_qos(hdr
->frame_control
))
1868 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST
;
1870 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr
)))
1871 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST
;
1873 return ieee80211_get_qos_ctl(hdr
)[0] & IEEE80211_QOS_CTL_TID_MASK
;
1876 static u8
ath10k_tx_h_get_vdev_id(struct ath10k
*ar
, struct ieee80211_vif
*vif
)
1879 return ath10k_vif_to_arvif(vif
)->vdev_id
;
1881 if (ar
->monitor_started
)
1882 return ar
->monitor_vdev_id
;
1884 ath10k_warn(ar
, "failed to resolve vdev id\n");
1888 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
1889 * Control in the header.
1891 static void ath10k_tx_h_nwifi(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
1893 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
1894 struct ath10k_skb_cb
*cb
= ATH10K_SKB_CB(skb
);
1897 if (!ieee80211_is_data_qos(hdr
->frame_control
))
1900 qos_ctl
= ieee80211_get_qos_ctl(hdr
);
1901 memmove(skb
->data
+ IEEE80211_QOS_CTL_LEN
,
1902 skb
->data
, (void *)qos_ctl
- (void *)skb
->data
);
1903 skb_pull(skb
, IEEE80211_QOS_CTL_LEN
);
1905 /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
1906 * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
1907 * used only for CQM purposes (e.g. hostapd station keepalive ping) so
1908 * it is safe to downgrade to NullFunc.
1910 if (ieee80211_is_qos_nullfunc(hdr
->frame_control
)) {
1911 hdr
->frame_control
&= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA
);
1912 cb
->htt
.tid
= HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST
;
1916 static void ath10k_tx_wep_key_work(struct work_struct
*work
)
1918 struct ath10k_vif
*arvif
= container_of(work
, struct ath10k_vif
,
1920 struct ath10k
*ar
= arvif
->ar
;
1921 int ret
, keyidx
= arvif
->def_wep_key_newidx
;
1923 mutex_lock(&arvif
->ar
->conf_mutex
);
1925 if (arvif
->ar
->state
!= ATH10K_STATE_ON
)
1928 if (arvif
->def_wep_key_idx
== keyidx
)
1931 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d set keyidx %d\n",
1932 arvif
->vdev_id
, keyidx
);
1934 ret
= ath10k_wmi_vdev_set_param(arvif
->ar
,
1936 arvif
->ar
->wmi
.vdev_param
->def_keyid
,
1939 ath10k_warn(ar
, "failed to update wep key index for vdev %d: %d\n",
1945 arvif
->def_wep_key_idx
= keyidx
;
1948 mutex_unlock(&arvif
->ar
->conf_mutex
);
1951 static void ath10k_tx_h_update_wep_key(struct ieee80211_vif
*vif
,
1952 struct ieee80211_key_conf
*key
,
1953 struct sk_buff
*skb
)
1955 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1956 struct ath10k
*ar
= arvif
->ar
;
1957 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1959 if (!ieee80211_has_protected(hdr
->frame_control
))
1965 if (key
->cipher
!= WLAN_CIPHER_SUITE_WEP40
&&
1966 key
->cipher
!= WLAN_CIPHER_SUITE_WEP104
)
1969 if (key
->keyidx
== arvif
->def_wep_key_idx
)
1972 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1973 * queueing frames until key index is updated is not an option because
1974 * sk_buff may need more processing to be done, e.g. offchannel */
1975 arvif
->def_wep_key_newidx
= key
->keyidx
;
1976 ieee80211_queue_work(ar
->hw
, &arvif
->wep_key_work
);
1979 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k
*ar
,
1980 struct ieee80211_vif
*vif
,
1981 struct sk_buff
*skb
)
1983 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1984 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1986 /* This is case only for P2P_GO */
1987 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
||
1988 arvif
->vdev_subtype
!= WMI_VDEV_SUBTYPE_P2P_GO
)
1991 if (unlikely(ieee80211_is_probe_resp(hdr
->frame_control
))) {
1992 spin_lock_bh(&ar
->data_lock
);
1993 if (arvif
->u
.ap
.noa_data
)
1994 if (!pskb_expand_head(skb
, 0, arvif
->u
.ap
.noa_len
,
1996 memcpy(skb_put(skb
, arvif
->u
.ap
.noa_len
),
1997 arvif
->u
.ap
.noa_data
,
1998 arvif
->u
.ap
.noa_len
);
1999 spin_unlock_bh(&ar
->data_lock
);
2003 static void ath10k_tx_htt(struct ath10k
*ar
, struct sk_buff
*skb
)
2005 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
2008 if (ar
->htt
.target_version_major
>= 3) {
2009 /* Since HTT 3.0 there is no separate mgmt tx command */
2010 ret
= ath10k_htt_tx(&ar
->htt
, skb
);
2014 if (ieee80211_is_mgmt(hdr
->frame_control
)) {
2015 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX
,
2017 if (skb_queue_len(&ar
->wmi_mgmt_tx_queue
) >=
2018 ATH10K_MAX_NUM_MGMT_PENDING
) {
2019 ath10k_warn(ar
, "reached WMI management transmit queue limit\n");
2024 skb_queue_tail(&ar
->wmi_mgmt_tx_queue
, skb
);
2025 ieee80211_queue_work(ar
->hw
, &ar
->wmi_mgmt_tx_work
);
2027 ret
= ath10k_htt_mgmt_tx(&ar
->htt
, skb
);
2029 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX
,
2031 ieee80211_is_nullfunc(hdr
->frame_control
)) {
2032 /* FW does not report tx status properly for NullFunc frames
2033 * unless they are sent through mgmt tx path. mac80211 sends
2034 * those frames when it detects link/beacon loss and depends
2035 * on the tx status to be correct. */
2036 ret
= ath10k_htt_mgmt_tx(&ar
->htt
, skb
);
2038 ret
= ath10k_htt_tx(&ar
->htt
, skb
);
2043 ath10k_warn(ar
, "failed to transmit packet, dropping: %d\n",
2045 ieee80211_free_txskb(ar
->hw
, skb
);
2049 void ath10k_offchan_tx_purge(struct ath10k
*ar
)
2051 struct sk_buff
*skb
;
2054 skb
= skb_dequeue(&ar
->offchan_tx_queue
);
2058 ieee80211_free_txskb(ar
->hw
, skb
);
2062 void ath10k_offchan_tx_work(struct work_struct
*work
)
2064 struct ath10k
*ar
= container_of(work
, struct ath10k
, offchan_tx_work
);
2065 struct ath10k_peer
*peer
;
2066 struct ieee80211_hdr
*hdr
;
2067 struct sk_buff
*skb
;
2068 const u8
*peer_addr
;
2072 /* FW requirement: We must create a peer before FW will send out
2073 * an offchannel frame. Otherwise the frame will be stuck and
2074 * never transmitted. We delete the peer upon tx completion.
2075 * It is unlikely that a peer for offchannel tx will already be
2076 * present. However it may be in some rare cases so account for that.
2077 * Otherwise we might remove a legitimate peer and break stuff. */
2080 skb
= skb_dequeue(&ar
->offchan_tx_queue
);
2084 mutex_lock(&ar
->conf_mutex
);
2086 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac offchannel skb %p\n",
2089 hdr
= (struct ieee80211_hdr
*)skb
->data
;
2090 peer_addr
= ieee80211_get_DA(hdr
);
2091 vdev_id
= ATH10K_SKB_CB(skb
)->vdev_id
;
2093 spin_lock_bh(&ar
->data_lock
);
2094 peer
= ath10k_peer_find(ar
, vdev_id
, peer_addr
);
2095 spin_unlock_bh(&ar
->data_lock
);
2098 /* FIXME: should this use ath10k_warn()? */
2099 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "peer %pM on vdev %d already present\n",
2100 peer_addr
, vdev_id
);
2103 ret
= ath10k_peer_create(ar
, vdev_id
, peer_addr
);
2105 ath10k_warn(ar
, "failed to create peer %pM on vdev %d: %d\n",
2106 peer_addr
, vdev_id
, ret
);
2109 spin_lock_bh(&ar
->data_lock
);
2110 reinit_completion(&ar
->offchan_tx_completed
);
2111 ar
->offchan_tx_skb
= skb
;
2112 spin_unlock_bh(&ar
->data_lock
);
2114 ath10k_tx_htt(ar
, skb
);
2116 ret
= wait_for_completion_timeout(&ar
->offchan_tx_completed
,
2119 ath10k_warn(ar
, "timed out waiting for offchannel skb %p\n",
2123 ret
= ath10k_peer_delete(ar
, vdev_id
, peer_addr
);
2125 ath10k_warn(ar
, "failed to delete peer %pM on vdev %d: %d\n",
2126 peer_addr
, vdev_id
, ret
);
2129 mutex_unlock(&ar
->conf_mutex
);
2133 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k
*ar
)
2135 struct sk_buff
*skb
;
2138 skb
= skb_dequeue(&ar
->wmi_mgmt_tx_queue
);
2142 ieee80211_free_txskb(ar
->hw
, skb
);
2146 void ath10k_mgmt_over_wmi_tx_work(struct work_struct
*work
)
2148 struct ath10k
*ar
= container_of(work
, struct ath10k
, wmi_mgmt_tx_work
);
2149 struct sk_buff
*skb
;
2153 skb
= skb_dequeue(&ar
->wmi_mgmt_tx_queue
);
2157 ret
= ath10k_wmi_mgmt_tx(ar
, skb
);
2159 ath10k_warn(ar
, "failed to transmit management frame via WMI: %d\n",
2161 ieee80211_free_txskb(ar
->hw
, skb
);
2170 void __ath10k_scan_finish(struct ath10k
*ar
)
2172 lockdep_assert_held(&ar
->data_lock
);
2174 switch (ar
->scan
.state
) {
2175 case ATH10K_SCAN_IDLE
:
2177 case ATH10K_SCAN_RUNNING
:
2178 case ATH10K_SCAN_ABORTING
:
2179 if (ar
->scan
.is_roc
)
2180 ieee80211_remain_on_channel_expired(ar
->hw
);
2182 ieee80211_scan_completed(ar
->hw
,
2184 ATH10K_SCAN_ABORTING
));
2186 case ATH10K_SCAN_STARTING
:
2187 ar
->scan
.state
= ATH10K_SCAN_IDLE
;
2188 ar
->scan_channel
= NULL
;
2189 ath10k_offchan_tx_purge(ar
);
2190 cancel_delayed_work(&ar
->scan
.timeout
);
2191 complete_all(&ar
->scan
.completed
);
2196 void ath10k_scan_finish(struct ath10k
*ar
)
2198 spin_lock_bh(&ar
->data_lock
);
2199 __ath10k_scan_finish(ar
);
2200 spin_unlock_bh(&ar
->data_lock
);
2203 static int ath10k_scan_stop(struct ath10k
*ar
)
2205 struct wmi_stop_scan_arg arg
= {
2206 .req_id
= 1, /* FIXME */
2207 .req_type
= WMI_SCAN_STOP_ONE
,
2208 .u
.scan_id
= ATH10K_SCAN_ID
,
2212 lockdep_assert_held(&ar
->conf_mutex
);
2214 ret
= ath10k_wmi_stop_scan(ar
, &arg
);
2216 ath10k_warn(ar
, "failed to stop wmi scan: %d\n", ret
);
2220 ret
= wait_for_completion_timeout(&ar
->scan
.completed
, 3*HZ
);
2222 ath10k_warn(ar
, "failed to receive scan abortion completion: timed out\n");
2224 } else if (ret
> 0) {
2229 /* Scan state should be updated upon scan completion but in case
2230 * firmware fails to deliver the event (for whatever reason) it is
2231 * desired to clean up scan state anyway. Firmware may have just
2232 * dropped the scan completion event delivery due to transport pipe
2233 * being overflown with data and/or it can recover on its own before
2234 * next scan request is submitted.
2236 spin_lock_bh(&ar
->data_lock
);
2237 if (ar
->scan
.state
!= ATH10K_SCAN_IDLE
)
2238 __ath10k_scan_finish(ar
);
2239 spin_unlock_bh(&ar
->data_lock
);
2244 static void ath10k_scan_abort(struct ath10k
*ar
)
2248 lockdep_assert_held(&ar
->conf_mutex
);
2250 spin_lock_bh(&ar
->data_lock
);
2252 switch (ar
->scan
.state
) {
2253 case ATH10K_SCAN_IDLE
:
2254 /* This can happen if timeout worker kicked in and called
2255 * abortion while scan completion was being processed.
2258 case ATH10K_SCAN_STARTING
:
2259 case ATH10K_SCAN_ABORTING
:
2260 ath10k_warn(ar
, "refusing scan abortion due to invalid scan state: %s (%d)\n",
2261 ath10k_scan_state_str(ar
->scan
.state
),
2264 case ATH10K_SCAN_RUNNING
:
2265 ar
->scan
.state
= ATH10K_SCAN_ABORTING
;
2266 spin_unlock_bh(&ar
->data_lock
);
2268 ret
= ath10k_scan_stop(ar
);
2270 ath10k_warn(ar
, "failed to abort scan: %d\n", ret
);
2272 spin_lock_bh(&ar
->data_lock
);
2276 spin_unlock_bh(&ar
->data_lock
);
2279 void ath10k_scan_timeout_work(struct work_struct
*work
)
2281 struct ath10k
*ar
= container_of(work
, struct ath10k
,
2284 mutex_lock(&ar
->conf_mutex
);
2285 ath10k_scan_abort(ar
);
2286 mutex_unlock(&ar
->conf_mutex
);
2289 static int ath10k_start_scan(struct ath10k
*ar
,
2290 const struct wmi_start_scan_arg
*arg
)
2294 lockdep_assert_held(&ar
->conf_mutex
);
2296 ret
= ath10k_wmi_start_scan(ar
, arg
);
2300 ret
= wait_for_completion_timeout(&ar
->scan
.started
, 1*HZ
);
2302 ret
= ath10k_scan_stop(ar
);
2304 ath10k_warn(ar
, "failed to stop scan: %d\n", ret
);
2309 /* Add a 200ms margin to account for event/command processing */
2310 ieee80211_queue_delayed_work(ar
->hw
, &ar
->scan
.timeout
,
2311 msecs_to_jiffies(arg
->max_scan_time
+200));
2315 /**********************/
2316 /* mac80211 callbacks */
2317 /**********************/
2319 static void ath10k_tx(struct ieee80211_hw
*hw
,
2320 struct ieee80211_tx_control
*control
,
2321 struct sk_buff
*skb
)
2323 struct ath10k
*ar
= hw
->priv
;
2324 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
2325 struct ieee80211_vif
*vif
= info
->control
.vif
;
2326 struct ieee80211_key_conf
*key
= info
->control
.hw_key
;
2327 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
2329 /* We should disable CCK RATE due to P2P */
2330 if (info
->flags
& IEEE80211_TX_CTL_NO_CCK_RATE
)
2331 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2333 ATH10K_SKB_CB(skb
)->htt
.is_offchan
= false;
2334 ATH10K_SKB_CB(skb
)->htt
.tid
= ath10k_tx_h_get_tid(hdr
);
2335 ATH10K_SKB_CB(skb
)->vdev_id
= ath10k_tx_h_get_vdev_id(ar
, vif
);
2337 /* it makes no sense to process injected frames like that */
2338 if (vif
&& vif
->type
!= NL80211_IFTYPE_MONITOR
) {
2339 ath10k_tx_h_nwifi(hw
, skb
);
2340 ath10k_tx_h_update_wep_key(vif
, key
, skb
);
2341 ath10k_tx_h_add_p2p_noa_ie(ar
, vif
, skb
);
2342 ath10k_tx_h_seq_no(vif
, skb
);
2345 if (info
->flags
& IEEE80211_TX_CTL_TX_OFFCHAN
) {
2346 spin_lock_bh(&ar
->data_lock
);
2347 ATH10K_SKB_CB(skb
)->htt
.is_offchan
= true;
2348 ATH10K_SKB_CB(skb
)->vdev_id
= ar
->scan
.vdev_id
;
2349 spin_unlock_bh(&ar
->data_lock
);
2351 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "queued offchannel skb %p\n",
2354 skb_queue_tail(&ar
->offchan_tx_queue
, skb
);
2355 ieee80211_queue_work(hw
, &ar
->offchan_tx_work
);
2359 ath10k_tx_htt(ar
, skb
);
2362 /* Must not be called with conf_mutex held as workers can use that also. */
2363 static void ath10k_drain_tx(struct ath10k
*ar
)
2365 /* make sure rcu-protected mac80211 tx path itself is drained */
2368 ath10k_offchan_tx_purge(ar
);
2369 ath10k_mgmt_over_wmi_tx_purge(ar
);
2371 cancel_work_sync(&ar
->offchan_tx_work
);
2372 cancel_work_sync(&ar
->wmi_mgmt_tx_work
);
2375 void ath10k_halt(struct ath10k
*ar
)
2377 struct ath10k_vif
*arvif
;
2379 lockdep_assert_held(&ar
->conf_mutex
);
2381 clear_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
2382 ar
->filter_flags
= 0;
2383 ar
->monitor
= false;
2385 if (ar
->monitor_started
)
2386 ath10k_monitor_stop(ar
);
2388 ar
->monitor_started
= false;
2390 ath10k_scan_finish(ar
);
2391 ath10k_peer_cleanup_all(ar
);
2392 ath10k_core_stop(ar
);
2393 ath10k_hif_power_down(ar
);
2395 spin_lock_bh(&ar
->data_lock
);
2396 list_for_each_entry(arvif
, &ar
->arvifs
, list
)
2397 ath10k_mac_vif_beacon_cleanup(arvif
);
2398 spin_unlock_bh(&ar
->data_lock
);
2401 static int ath10k_get_antenna(struct ieee80211_hw
*hw
, u32
*tx_ant
, u32
*rx_ant
)
2403 struct ath10k
*ar
= hw
->priv
;
2405 mutex_lock(&ar
->conf_mutex
);
2407 if (ar
->cfg_tx_chainmask
) {
2408 *tx_ant
= ar
->cfg_tx_chainmask
;
2409 *rx_ant
= ar
->cfg_rx_chainmask
;
2411 *tx_ant
= ar
->supp_tx_chainmask
;
2412 *rx_ant
= ar
->supp_rx_chainmask
;
2415 mutex_unlock(&ar
->conf_mutex
);
2420 static int __ath10k_set_antenna(struct ath10k
*ar
, u32 tx_ant
, u32 rx_ant
)
2424 lockdep_assert_held(&ar
->conf_mutex
);
2426 ar
->cfg_tx_chainmask
= tx_ant
;
2427 ar
->cfg_rx_chainmask
= rx_ant
;
2429 if ((ar
->state
!= ATH10K_STATE_ON
) &&
2430 (ar
->state
!= ATH10K_STATE_RESTARTED
))
2433 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->tx_chain_mask
,
2436 ath10k_warn(ar
, "failed to set tx-chainmask: %d, req 0x%x\n",
2441 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->rx_chain_mask
,
2444 ath10k_warn(ar
, "failed to set rx-chainmask: %d, req 0x%x\n",
2452 static int ath10k_set_antenna(struct ieee80211_hw
*hw
, u32 tx_ant
, u32 rx_ant
)
2454 struct ath10k
*ar
= hw
->priv
;
2457 mutex_lock(&ar
->conf_mutex
);
2458 ret
= __ath10k_set_antenna(ar
, tx_ant
, rx_ant
);
2459 mutex_unlock(&ar
->conf_mutex
);
2463 static int ath10k_start(struct ieee80211_hw
*hw
)
2465 struct ath10k
*ar
= hw
->priv
;
2469 * This makes sense only when restarting hw. It is harmless to call
2470 * uncoditionally. This is necessary to make sure no HTT/WMI tx
2471 * commands will be submitted while restarting.
2473 ath10k_drain_tx(ar
);
2475 mutex_lock(&ar
->conf_mutex
);
2477 switch (ar
->state
) {
2478 case ATH10K_STATE_OFF
:
2479 ar
->state
= ATH10K_STATE_ON
;
2481 case ATH10K_STATE_RESTARTING
:
2483 ar
->state
= ATH10K_STATE_RESTARTED
;
2485 case ATH10K_STATE_ON
:
2486 case ATH10K_STATE_RESTARTED
:
2487 case ATH10K_STATE_WEDGED
:
2491 case ATH10K_STATE_UTF
:
2496 ret
= ath10k_hif_power_up(ar
);
2498 ath10k_err(ar
, "Could not init hif: %d\n", ret
);
2502 ret
= ath10k_core_start(ar
, ATH10K_FIRMWARE_MODE_NORMAL
);
2504 ath10k_err(ar
, "Could not init core: %d\n", ret
);
2505 goto err_power_down
;
2508 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->pmf_qos
, 1);
2510 ath10k_warn(ar
, "failed to enable PMF QOS: %d\n", ret
);
2514 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->dynamic_bw
, 1);
2516 ath10k_warn(ar
, "failed to enable dynamic BW: %d\n", ret
);
2520 if (ar
->cfg_tx_chainmask
)
2521 __ath10k_set_antenna(ar
, ar
->cfg_tx_chainmask
,
2522 ar
->cfg_rx_chainmask
);
2525 * By default FW set ARP frames ac to voice (6). In that case ARP
2526 * exchange is not working properly for UAPSD enabled AP. ARP requests
2527 * which arrives with access category 0 are processed by network stack
2528 * and send back with access category 0, but FW changes access category
2529 * to 6. Set ARP frames access category to best effort (0) solves
2533 ret
= ath10k_wmi_pdev_set_param(ar
,
2534 ar
->wmi
.pdev_param
->arp_ac_override
, 0);
2536 ath10k_warn(ar
, "failed to set arp ac override parameter: %d\n",
2541 ar
->num_started_vdevs
= 0;
2542 ath10k_regd_update(ar
);
2544 ath10k_spectral_start(ar
);
2546 mutex_unlock(&ar
->conf_mutex
);
2550 ath10k_core_stop(ar
);
2553 ath10k_hif_power_down(ar
);
2556 ar
->state
= ATH10K_STATE_OFF
;
2559 mutex_unlock(&ar
->conf_mutex
);
2563 static void ath10k_stop(struct ieee80211_hw
*hw
)
2565 struct ath10k
*ar
= hw
->priv
;
2567 ath10k_drain_tx(ar
);
2569 mutex_lock(&ar
->conf_mutex
);
2570 if (ar
->state
!= ATH10K_STATE_OFF
) {
2572 ar
->state
= ATH10K_STATE_OFF
;
2574 mutex_unlock(&ar
->conf_mutex
);
2576 cancel_delayed_work_sync(&ar
->scan
.timeout
);
2577 cancel_work_sync(&ar
->restart_work
);
2580 static int ath10k_config_ps(struct ath10k
*ar
)
2582 struct ath10k_vif
*arvif
;
2585 lockdep_assert_held(&ar
->conf_mutex
);
2587 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
2588 ret
= ath10k_mac_vif_setup_ps(arvif
);
2590 ath10k_warn(ar
, "failed to setup powersave: %d\n", ret
);
2598 static const char *chandef_get_width(enum nl80211_chan_width width
)
2601 case NL80211_CHAN_WIDTH_20_NOHT
:
2603 case NL80211_CHAN_WIDTH_20
:
2605 case NL80211_CHAN_WIDTH_40
:
2607 case NL80211_CHAN_WIDTH_80
:
2609 case NL80211_CHAN_WIDTH_80P80
:
2611 case NL80211_CHAN_WIDTH_160
:
2613 case NL80211_CHAN_WIDTH_5
:
2615 case NL80211_CHAN_WIDTH_10
:
2621 static void ath10k_config_chan(struct ath10k
*ar
)
2623 struct ath10k_vif
*arvif
;
2626 lockdep_assert_held(&ar
->conf_mutex
);
2628 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
2629 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2630 ar
->chandef
.chan
->center_freq
,
2631 ar
->chandef
.center_freq1
,
2632 ar
->chandef
.center_freq2
,
2633 chandef_get_width(ar
->chandef
.width
));
2635 /* First stop monitor interface. Some FW versions crash if there's a
2636 * lone monitor interface. */
2637 if (ar
->monitor_started
)
2638 ath10k_monitor_stop(ar
);
2640 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
2641 if (!arvif
->is_started
)
2647 if (arvif
->vdev_type
== WMI_VDEV_TYPE_MONITOR
)
2650 ret
= ath10k_wmi_vdev_down(ar
, arvif
->vdev_id
);
2652 ath10k_warn(ar
, "failed to down vdev %d: %d\n",
2653 arvif
->vdev_id
, ret
);
2658 /* all vdevs are downed now - attempt to restart and re-up them */
2660 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
2661 if (!arvif
->is_started
)
2664 if (arvif
->vdev_type
== WMI_VDEV_TYPE_MONITOR
)
2667 ret
= ath10k_vdev_restart(arvif
);
2669 ath10k_warn(ar
, "failed to restart vdev %d: %d\n",
2670 arvif
->vdev_id
, ret
);
2677 ret
= ath10k_wmi_vdev_up(arvif
->ar
, arvif
->vdev_id
, arvif
->aid
,
2680 ath10k_warn(ar
, "failed to bring vdev up %d: %d\n",
2681 arvif
->vdev_id
, ret
);
2686 ath10k_monitor_recalc(ar
);
2689 static int ath10k_config(struct ieee80211_hw
*hw
, u32 changed
)
2691 struct ath10k
*ar
= hw
->priv
;
2692 struct ieee80211_conf
*conf
= &hw
->conf
;
2696 mutex_lock(&ar
->conf_mutex
);
2698 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
) {
2699 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
2700 "mac config channel %dMHz flags 0x%x radar %d\n",
2701 conf
->chandef
.chan
->center_freq
,
2702 conf
->chandef
.chan
->flags
,
2703 conf
->radar_enabled
);
2705 spin_lock_bh(&ar
->data_lock
);
2706 ar
->rx_channel
= conf
->chandef
.chan
;
2707 spin_unlock_bh(&ar
->data_lock
);
2709 ar
->radar_enabled
= conf
->radar_enabled
;
2710 ath10k_recalc_radar_detection(ar
);
2712 if (!cfg80211_chandef_identical(&ar
->chandef
, &conf
->chandef
)) {
2713 ar
->chandef
= conf
->chandef
;
2714 ath10k_config_chan(ar
);
2718 if (changed
& IEEE80211_CONF_CHANGE_POWER
) {
2719 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac config power %d\n",
2720 hw
->conf
.power_level
);
2722 param
= ar
->wmi
.pdev_param
->txpower_limit2g
;
2723 ret
= ath10k_wmi_pdev_set_param(ar
, param
,
2724 hw
->conf
.power_level
* 2);
2726 ath10k_warn(ar
, "failed to set 2g txpower %d: %d\n",
2727 hw
->conf
.power_level
, ret
);
2729 param
= ar
->wmi
.pdev_param
->txpower_limit5g
;
2730 ret
= ath10k_wmi_pdev_set_param(ar
, param
,
2731 hw
->conf
.power_level
* 2);
2733 ath10k_warn(ar
, "failed to set 5g txpower %d: %d\n",
2734 hw
->conf
.power_level
, ret
);
2737 if (changed
& IEEE80211_CONF_CHANGE_PS
)
2738 ath10k_config_ps(ar
);
2740 if (changed
& IEEE80211_CONF_CHANGE_MONITOR
) {
2741 ar
->monitor
= conf
->flags
& IEEE80211_CONF_MONITOR
;
2742 ret
= ath10k_monitor_recalc(ar
);
2744 ath10k_warn(ar
, "failed to recalc monitor: %d\n", ret
);
2747 mutex_unlock(&ar
->conf_mutex
);
2753 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2754 * because we will send mgmt frames without CCK. This requirement
2755 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2758 static int ath10k_add_interface(struct ieee80211_hw
*hw
,
2759 struct ieee80211_vif
*vif
)
2761 struct ath10k
*ar
= hw
->priv
;
2762 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2763 enum wmi_sta_powersave_param param
;
2769 mutex_lock(&ar
->conf_mutex
);
2771 memset(arvif
, 0, sizeof(*arvif
));
2776 INIT_WORK(&arvif
->wep_key_work
, ath10k_tx_wep_key_work
);
2777 INIT_LIST_HEAD(&arvif
->list
);
2779 if (ar
->free_vdev_map
== 0) {
2780 ath10k_warn(ar
, "Free vdev map is empty, no more interfaces allowed.\n");
2784 bit
= __ffs64(ar
->free_vdev_map
);
2786 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac create vdev %i map %llx\n",
2787 bit
, ar
->free_vdev_map
);
2789 arvif
->vdev_id
= bit
;
2790 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_NONE
;
2793 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_P2P_DEVICE
;
2795 switch (vif
->type
) {
2796 case NL80211_IFTYPE_UNSPECIFIED
:
2797 case NL80211_IFTYPE_STATION
:
2798 arvif
->vdev_type
= WMI_VDEV_TYPE_STA
;
2800 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_P2P_CLIENT
;
2802 case NL80211_IFTYPE_ADHOC
:
2803 arvif
->vdev_type
= WMI_VDEV_TYPE_IBSS
;
2805 case NL80211_IFTYPE_AP
:
2806 arvif
->vdev_type
= WMI_VDEV_TYPE_AP
;
2809 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_P2P_GO
;
2811 case NL80211_IFTYPE_MONITOR
:
2812 arvif
->vdev_type
= WMI_VDEV_TYPE_MONITOR
;
2819 /* Some firmware revisions don't wait for beacon tx completion before
2820 * sending another SWBA event. This could lead to hardware using old
2821 * (freed) beacon data in some cases, e.g. tx credit starvation
2822 * combined with missed TBTT. This is very very rare.
2824 * On non-IOMMU-enabled hosts this could be a possible security issue
2825 * because hw could beacon some random data on the air. On
2826 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
2827 * device would crash.
2829 * Since there are no beacon tx completions (implicit nor explicit)
2830 * propagated to host the only workaround for this is to allocate a
2831 * DMA-coherent buffer for a lifetime of a vif and use it for all
2832 * beacon tx commands. Worst case for this approach is some beacons may
2833 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
2835 if (vif
->type
== NL80211_IFTYPE_ADHOC
||
2836 vif
->type
== NL80211_IFTYPE_AP
) {
2837 arvif
->beacon_buf
= dma_zalloc_coherent(ar
->dev
,
2838 IEEE80211_MAX_FRAME_LEN
,
2839 &arvif
->beacon_paddr
,
2841 if (!arvif
->beacon_buf
) {
2843 ath10k_warn(ar
, "failed to allocate beacon buffer: %d\n",
2849 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
2850 arvif
->vdev_id
, arvif
->vdev_type
, arvif
->vdev_subtype
,
2851 arvif
->beacon_buf
? "single-buf" : "per-skb");
2853 ret
= ath10k_wmi_vdev_create(ar
, arvif
->vdev_id
, arvif
->vdev_type
,
2854 arvif
->vdev_subtype
, vif
->addr
);
2856 ath10k_warn(ar
, "failed to create WMI vdev %i: %d\n",
2857 arvif
->vdev_id
, ret
);
2861 ar
->free_vdev_map
&= ~(1LL << arvif
->vdev_id
);
2862 list_add(&arvif
->list
, &ar
->arvifs
);
2864 vdev_param
= ar
->wmi
.vdev_param
->def_keyid
;
2865 ret
= ath10k_wmi_vdev_set_param(ar
, 0, vdev_param
,
2866 arvif
->def_wep_key_idx
);
2868 ath10k_warn(ar
, "failed to set vdev %i default key id: %d\n",
2869 arvif
->vdev_id
, ret
);
2870 goto err_vdev_delete
;
2873 vdev_param
= ar
->wmi
.vdev_param
->tx_encap_type
;
2874 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
2875 ATH10K_HW_TXRX_NATIVE_WIFI
);
2876 /* 10.X firmware does not support this VDEV parameter. Do not warn */
2877 if (ret
&& ret
!= -EOPNOTSUPP
) {
2878 ath10k_warn(ar
, "failed to set vdev %i TX encapsulation: %d\n",
2879 arvif
->vdev_id
, ret
);
2880 goto err_vdev_delete
;
2883 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
) {
2884 ret
= ath10k_peer_create(ar
, arvif
->vdev_id
, vif
->addr
);
2886 ath10k_warn(ar
, "failed to create vdev %i peer for AP: %d\n",
2887 arvif
->vdev_id
, ret
);
2888 goto err_vdev_delete
;
2891 ret
= ath10k_mac_set_kickout(arvif
);
2893 ath10k_warn(ar
, "failed to set vdev %i kickout parameters: %d\n",
2894 arvif
->vdev_id
, ret
);
2895 goto err_peer_delete
;
2899 if (arvif
->vdev_type
== WMI_VDEV_TYPE_STA
) {
2900 param
= WMI_STA_PS_PARAM_RX_WAKE_POLICY
;
2901 value
= WMI_STA_PS_RX_WAKE_POLICY_WAKE
;
2902 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
2905 ath10k_warn(ar
, "failed to set vdev %i RX wake policy: %d\n",
2906 arvif
->vdev_id
, ret
);
2907 goto err_peer_delete
;
2910 param
= WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD
;
2911 value
= WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS
;
2912 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
2915 ath10k_warn(ar
, "failed to set vdev %i TX wake thresh: %d\n",
2916 arvif
->vdev_id
, ret
);
2917 goto err_peer_delete
;
2920 param
= WMI_STA_PS_PARAM_PSPOLL_COUNT
;
2921 value
= WMI_STA_PS_PSPOLL_COUNT_NO_MAX
;
2922 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
2925 ath10k_warn(ar
, "failed to set vdev %i PSPOLL count: %d\n",
2926 arvif
->vdev_id
, ret
);
2927 goto err_peer_delete
;
2931 ret
= ath10k_mac_set_rts(arvif
, ar
->hw
->wiphy
->rts_threshold
);
2933 ath10k_warn(ar
, "failed to set rts threshold for vdev %d: %d\n",
2934 arvif
->vdev_id
, ret
);
2935 goto err_peer_delete
;
2938 ret
= ath10k_mac_set_frag(arvif
, ar
->hw
->wiphy
->frag_threshold
);
2940 ath10k_warn(ar
, "failed to set frag threshold for vdev %d: %d\n",
2941 arvif
->vdev_id
, ret
);
2942 goto err_peer_delete
;
2945 mutex_unlock(&ar
->conf_mutex
);
2949 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
)
2950 ath10k_wmi_peer_delete(ar
, arvif
->vdev_id
, vif
->addr
);
2953 ath10k_wmi_vdev_delete(ar
, arvif
->vdev_id
);
2954 ar
->free_vdev_map
|= 1LL << arvif
->vdev_id
;
2955 list_del(&arvif
->list
);
2958 if (arvif
->beacon_buf
) {
2959 dma_free_coherent(ar
->dev
, IEEE80211_MAX_FRAME_LEN
,
2960 arvif
->beacon_buf
, arvif
->beacon_paddr
);
2961 arvif
->beacon_buf
= NULL
;
2964 mutex_unlock(&ar
->conf_mutex
);
2969 static void ath10k_remove_interface(struct ieee80211_hw
*hw
,
2970 struct ieee80211_vif
*vif
)
2972 struct ath10k
*ar
= hw
->priv
;
2973 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2976 mutex_lock(&ar
->conf_mutex
);
2978 cancel_work_sync(&arvif
->wep_key_work
);
2980 spin_lock_bh(&ar
->data_lock
);
2981 ath10k_mac_vif_beacon_cleanup(arvif
);
2982 spin_unlock_bh(&ar
->data_lock
);
2984 ret
= ath10k_spectral_vif_stop(arvif
);
2986 ath10k_warn(ar
, "failed to stop spectral for vdev %i: %d\n",
2987 arvif
->vdev_id
, ret
);
2989 ar
->free_vdev_map
|= 1LL << arvif
->vdev_id
;
2990 list_del(&arvif
->list
);
2992 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
) {
2993 ret
= ath10k_peer_delete(arvif
->ar
, arvif
->vdev_id
, vif
->addr
);
2995 ath10k_warn(ar
, "failed to remove peer for AP vdev %i: %d\n",
2996 arvif
->vdev_id
, ret
);
2998 kfree(arvif
->u
.ap
.noa_data
);
3001 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %i delete (remove interface)\n",
3004 ret
= ath10k_wmi_vdev_delete(ar
, arvif
->vdev_id
);
3006 ath10k_warn(ar
, "failed to delete WMI vdev %i: %d\n",
3007 arvif
->vdev_id
, ret
);
3009 ath10k_peer_cleanup(ar
, arvif
->vdev_id
);
3011 mutex_unlock(&ar
->conf_mutex
);
3015 * FIXME: Has to be verified.
3017 #define SUPPORTED_FILTERS \
3018 (FIF_PROMISC_IN_BSS | \
3023 FIF_BCN_PRBRESP_PROMISC | \
3027 static void ath10k_configure_filter(struct ieee80211_hw
*hw
,
3028 unsigned int changed_flags
,
3029 unsigned int *total_flags
,
3032 struct ath10k
*ar
= hw
->priv
;
3035 mutex_lock(&ar
->conf_mutex
);
3037 changed_flags
&= SUPPORTED_FILTERS
;
3038 *total_flags
&= SUPPORTED_FILTERS
;
3039 ar
->filter_flags
= *total_flags
;
3041 ret
= ath10k_monitor_recalc(ar
);
3043 ath10k_warn(ar
, "failed to recalc montior: %d\n", ret
);
3045 mutex_unlock(&ar
->conf_mutex
);
3048 static void ath10k_bss_info_changed(struct ieee80211_hw
*hw
,
3049 struct ieee80211_vif
*vif
,
3050 struct ieee80211_bss_conf
*info
,
3053 struct ath10k
*ar
= hw
->priv
;
3054 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3056 u32 vdev_param
, pdev_param
, slottime
, preamble
;
3058 mutex_lock(&ar
->conf_mutex
);
3060 if (changed
& BSS_CHANGED_IBSS
)
3061 ath10k_control_ibss(arvif
, info
, vif
->addr
);
3063 if (changed
& BSS_CHANGED_BEACON_INT
) {
3064 arvif
->beacon_interval
= info
->beacon_int
;
3065 vdev_param
= ar
->wmi
.vdev_param
->beacon_interval
;
3066 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
3067 arvif
->beacon_interval
);
3068 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3069 "mac vdev %d beacon_interval %d\n",
3070 arvif
->vdev_id
, arvif
->beacon_interval
);
3073 ath10k_warn(ar
, "failed to set beacon interval for vdev %d: %i\n",
3074 arvif
->vdev_id
, ret
);
3077 if (changed
& BSS_CHANGED_BEACON
) {
3078 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3079 "vdev %d set beacon tx mode to staggered\n",
3082 pdev_param
= ar
->wmi
.pdev_param
->beacon_tx_mode
;
3083 ret
= ath10k_wmi_pdev_set_param(ar
, pdev_param
,
3084 WMI_BEACON_STAGGERED_MODE
);
3086 ath10k_warn(ar
, "failed to set beacon mode for vdev %d: %i\n",
3087 arvif
->vdev_id
, ret
);
3090 if (changed
& BSS_CHANGED_BEACON_INFO
) {
3091 arvif
->dtim_period
= info
->dtim_period
;
3093 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3094 "mac vdev %d dtim_period %d\n",
3095 arvif
->vdev_id
, arvif
->dtim_period
);
3097 vdev_param
= ar
->wmi
.vdev_param
->dtim_period
;
3098 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
3099 arvif
->dtim_period
);
3101 ath10k_warn(ar
, "failed to set dtim period for vdev %d: %i\n",
3102 arvif
->vdev_id
, ret
);
3105 if (changed
& BSS_CHANGED_SSID
&&
3106 vif
->type
== NL80211_IFTYPE_AP
) {
3107 arvif
->u
.ap
.ssid_len
= info
->ssid_len
;
3109 memcpy(arvif
->u
.ap
.ssid
, info
->ssid
, info
->ssid_len
);
3110 arvif
->u
.ap
.hidden_ssid
= info
->hidden_ssid
;
3114 * Firmware manages AP self-peer internally so make sure to not create
3115 * it in driver. Otherwise AP self-peer deletion may timeout later.
3117 if (changed
& BSS_CHANGED_BSSID
&&
3118 vif
->type
!= NL80211_IFTYPE_AP
) {
3119 if (!is_zero_ether_addr(info
->bssid
)) {
3120 if (vif
->type
== NL80211_IFTYPE_STATION
) {
3121 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3122 "mac vdev %d create peer %pM\n",
3123 arvif
->vdev_id
, info
->bssid
);
3125 ret
= ath10k_peer_create(ar
, arvif
->vdev_id
,
3128 ath10k_warn(ar
, "failed to add peer %pM for vdev %d when changing bssid: %i\n",
3129 info
->bssid
, arvif
->vdev_id
,
3132 * this is never erased as we it for crypto key
3133 * clearing; this is FW requirement
3135 ether_addr_copy(arvif
->bssid
, info
->bssid
);
3137 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3138 "mac vdev %d start %pM\n",
3139 arvif
->vdev_id
, info
->bssid
);
3141 ret
= ath10k_vdev_start(arvif
);
3143 ath10k_warn(ar
, "failed to start vdev %i: %d\n",
3144 arvif
->vdev_id
, ret
);
3148 arvif
->is_started
= true;
3152 * Mac80211 does not keep IBSS bssid when leaving IBSS,
3153 * so driver need to store it. It is needed when leaving
3154 * IBSS in order to remove BSSID peer.
3156 if (vif
->type
== NL80211_IFTYPE_ADHOC
)
3157 memcpy(arvif
->bssid
, info
->bssid
,
3162 if (changed
& BSS_CHANGED_BEACON_ENABLED
)
3163 ath10k_control_beaconing(arvif
, info
);
3165 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
3166 arvif
->use_cts_prot
= info
->use_cts_prot
;
3167 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d cts_prot %d\n",
3168 arvif
->vdev_id
, info
->use_cts_prot
);
3170 ret
= ath10k_recalc_rtscts_prot(arvif
);
3172 ath10k_warn(ar
, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3173 arvif
->vdev_id
, ret
);
3176 if (changed
& BSS_CHANGED_ERP_SLOT
) {
3177 if (info
->use_short_slot
)
3178 slottime
= WMI_VDEV_SLOT_TIME_SHORT
; /* 9us */
3181 slottime
= WMI_VDEV_SLOT_TIME_LONG
; /* 20us */
3183 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d slot_time %d\n",
3184 arvif
->vdev_id
, slottime
);
3186 vdev_param
= ar
->wmi
.vdev_param
->slot_time
;
3187 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
3190 ath10k_warn(ar
, "failed to set erp slot for vdev %d: %i\n",
3191 arvif
->vdev_id
, ret
);
3194 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
3195 if (info
->use_short_preamble
)
3196 preamble
= WMI_VDEV_PREAMBLE_SHORT
;
3198 preamble
= WMI_VDEV_PREAMBLE_LONG
;
3200 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3201 "mac vdev %d preamble %dn",
3202 arvif
->vdev_id
, preamble
);
3204 vdev_param
= ar
->wmi
.vdev_param
->preamble
;
3205 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
3208 ath10k_warn(ar
, "failed to set preamble for vdev %d: %i\n",
3209 arvif
->vdev_id
, ret
);
3212 if (changed
& BSS_CHANGED_ASSOC
) {
3214 /* Workaround: Make sure monitor vdev is not running
3215 * when associating to prevent some firmware revisions
3216 * (e.g. 10.1 and 10.2) from crashing.
3218 if (ar
->monitor_started
)
3219 ath10k_monitor_stop(ar
);
3220 ath10k_bss_assoc(hw
, vif
, info
);
3221 ath10k_monitor_recalc(ar
);
3226 mutex_unlock(&ar
->conf_mutex
);
3229 static int ath10k_hw_scan(struct ieee80211_hw
*hw
,
3230 struct ieee80211_vif
*vif
,
3231 struct ieee80211_scan_request
*hw_req
)
3233 struct ath10k
*ar
= hw
->priv
;
3234 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3235 struct cfg80211_scan_request
*req
= &hw_req
->req
;
3236 struct wmi_start_scan_arg arg
;
3240 mutex_lock(&ar
->conf_mutex
);
3242 spin_lock_bh(&ar
->data_lock
);
3243 switch (ar
->scan
.state
) {
3244 case ATH10K_SCAN_IDLE
:
3245 reinit_completion(&ar
->scan
.started
);
3246 reinit_completion(&ar
->scan
.completed
);
3247 ar
->scan
.state
= ATH10K_SCAN_STARTING
;
3248 ar
->scan
.is_roc
= false;
3249 ar
->scan
.vdev_id
= arvif
->vdev_id
;
3252 case ATH10K_SCAN_STARTING
:
3253 case ATH10K_SCAN_RUNNING
:
3254 case ATH10K_SCAN_ABORTING
:
3258 spin_unlock_bh(&ar
->data_lock
);
3263 memset(&arg
, 0, sizeof(arg
));
3264 ath10k_wmi_start_scan_init(ar
, &arg
);
3265 arg
.vdev_id
= arvif
->vdev_id
;
3266 arg
.scan_id
= ATH10K_SCAN_ID
;
3269 arg
.scan_ctrl_flags
|= WMI_SCAN_ADD_CCK_RATES
;
3272 arg
.ie_len
= req
->ie_len
;
3273 memcpy(arg
.ie
, req
->ie
, arg
.ie_len
);
3277 arg
.n_ssids
= req
->n_ssids
;
3278 for (i
= 0; i
< arg
.n_ssids
; i
++) {
3279 arg
.ssids
[i
].len
= req
->ssids
[i
].ssid_len
;
3280 arg
.ssids
[i
].ssid
= req
->ssids
[i
].ssid
;
3283 arg
.scan_ctrl_flags
|= WMI_SCAN_FLAG_PASSIVE
;
3286 if (req
->n_channels
) {
3287 arg
.n_channels
= req
->n_channels
;
3288 for (i
= 0; i
< arg
.n_channels
; i
++)
3289 arg
.channels
[i
] = req
->channels
[i
]->center_freq
;
3292 ret
= ath10k_start_scan(ar
, &arg
);
3294 ath10k_warn(ar
, "failed to start hw scan: %d\n", ret
);
3295 spin_lock_bh(&ar
->data_lock
);
3296 ar
->scan
.state
= ATH10K_SCAN_IDLE
;
3297 spin_unlock_bh(&ar
->data_lock
);
3301 mutex_unlock(&ar
->conf_mutex
);
3305 static void ath10k_cancel_hw_scan(struct ieee80211_hw
*hw
,
3306 struct ieee80211_vif
*vif
)
3308 struct ath10k
*ar
= hw
->priv
;
3310 mutex_lock(&ar
->conf_mutex
);
3311 cancel_delayed_work_sync(&ar
->scan
.timeout
);
3312 ath10k_scan_abort(ar
);
3313 mutex_unlock(&ar
->conf_mutex
);
3316 static void ath10k_set_key_h_def_keyidx(struct ath10k
*ar
,
3317 struct ath10k_vif
*arvif
,
3318 enum set_key_cmd cmd
,
3319 struct ieee80211_key_conf
*key
)
3321 u32 vdev_param
= arvif
->ar
->wmi
.vdev_param
->def_keyid
;
3324 /* 10.1 firmware branch requires default key index to be set to group
3325 * key index after installing it. Otherwise FW/HW Txes corrupted
3326 * frames with multi-vif APs. This is not required for main firmware
3327 * branch (e.g. 636).
3329 * FIXME: This has been tested only in AP. It remains unknown if this
3330 * is required for multi-vif STA interfaces on 10.1 */
3332 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
)
3335 if (key
->cipher
== WLAN_CIPHER_SUITE_WEP40
)
3338 if (key
->cipher
== WLAN_CIPHER_SUITE_WEP104
)
3341 if (key
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
)
3347 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
3350 ath10k_warn(ar
, "failed to set vdev %i group key as default key: %d\n",
3351 arvif
->vdev_id
, ret
);
3354 static int ath10k_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
3355 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
3356 struct ieee80211_key_conf
*key
)
3358 struct ath10k
*ar
= hw
->priv
;
3359 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3360 struct ath10k_peer
*peer
;
3361 const u8
*peer_addr
;
3362 bool is_wep
= key
->cipher
== WLAN_CIPHER_SUITE_WEP40
||
3363 key
->cipher
== WLAN_CIPHER_SUITE_WEP104
;
3366 if (key
->keyidx
> WMI_MAX_KEY_INDEX
)
3369 mutex_lock(&ar
->conf_mutex
);
3372 peer_addr
= sta
->addr
;
3373 else if (arvif
->vdev_type
== WMI_VDEV_TYPE_STA
)
3374 peer_addr
= vif
->bss_conf
.bssid
;
3376 peer_addr
= vif
->addr
;
3378 key
->hw_key_idx
= key
->keyidx
;
3380 /* the peer should not disappear in mid-way (unless FW goes awry) since
3381 * we already hold conf_mutex. we just make sure its there now. */
3382 spin_lock_bh(&ar
->data_lock
);
3383 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, peer_addr
);
3384 spin_unlock_bh(&ar
->data_lock
);
3387 if (cmd
== SET_KEY
) {
3388 ath10k_warn(ar
, "failed to install key for non-existent peer %pM\n",
3393 /* if the peer doesn't exist there is no key to disable
3401 arvif
->wep_keys
[key
->keyidx
] = key
;
3403 arvif
->wep_keys
[key
->keyidx
] = NULL
;
3405 if (cmd
== DISABLE_KEY
)
3406 ath10k_clear_vdev_key(arvif
, key
);
3409 ret
= ath10k_install_key(arvif
, key
, cmd
, peer_addr
);
3411 ath10k_warn(ar
, "failed to install key for vdev %i peer %pM: %d\n",
3412 arvif
->vdev_id
, peer_addr
, ret
);
3416 ath10k_set_key_h_def_keyidx(ar
, arvif
, cmd
, key
);
3418 spin_lock_bh(&ar
->data_lock
);
3419 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, peer_addr
);
3420 if (peer
&& cmd
== SET_KEY
)
3421 peer
->keys
[key
->keyidx
] = key
;
3422 else if (peer
&& cmd
== DISABLE_KEY
)
3423 peer
->keys
[key
->keyidx
] = NULL
;
3424 else if (peer
== NULL
)
3425 /* impossible unless FW goes crazy */
3426 ath10k_warn(ar
, "Peer %pM disappeared!\n", peer_addr
);
3427 spin_unlock_bh(&ar
->data_lock
);
3430 mutex_unlock(&ar
->conf_mutex
);
3434 static void ath10k_sta_rc_update_wk(struct work_struct
*wk
)
3437 struct ath10k_vif
*arvif
;
3438 struct ath10k_sta
*arsta
;
3439 struct ieee80211_sta
*sta
;
3440 u32 changed
, bw
, nss
, smps
;
3443 arsta
= container_of(wk
, struct ath10k_sta
, update_wk
);
3444 sta
= container_of((void *)arsta
, struct ieee80211_sta
, drv_priv
);
3445 arvif
= arsta
->arvif
;
3448 spin_lock_bh(&ar
->data_lock
);
3450 changed
= arsta
->changed
;
3457 spin_unlock_bh(&ar
->data_lock
);
3459 mutex_lock(&ar
->conf_mutex
);
3461 if (changed
& IEEE80211_RC_BW_CHANGED
) {
3462 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM peer bw %d\n",
3465 err
= ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, sta
->addr
,
3466 WMI_PEER_CHAN_WIDTH
, bw
);
3468 ath10k_warn(ar
, "failed to update STA %pM peer bw %d: %d\n",
3469 sta
->addr
, bw
, err
);
3472 if (changed
& IEEE80211_RC_NSS_CHANGED
) {
3473 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM nss %d\n",
3476 err
= ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, sta
->addr
,
3479 ath10k_warn(ar
, "failed to update STA %pM nss %d: %d\n",
3480 sta
->addr
, nss
, err
);
3483 if (changed
& IEEE80211_RC_SMPS_CHANGED
) {
3484 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM smps %d\n",
3487 err
= ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, sta
->addr
,
3488 WMI_PEER_SMPS_STATE
, smps
);
3490 ath10k_warn(ar
, "failed to update STA %pM smps %d: %d\n",
3491 sta
->addr
, smps
, err
);
3494 if (changed
& IEEE80211_RC_SUPP_RATES_CHANGED
) {
3495 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM supp rates\n",
3498 err
= ath10k_station_assoc(ar
, arvif
->vif
, sta
, true);
3500 ath10k_warn(ar
, "failed to reassociate station: %pM\n",
3504 mutex_unlock(&ar
->conf_mutex
);
3507 static int ath10k_sta_state(struct ieee80211_hw
*hw
,
3508 struct ieee80211_vif
*vif
,
3509 struct ieee80211_sta
*sta
,
3510 enum ieee80211_sta_state old_state
,
3511 enum ieee80211_sta_state new_state
)
3513 struct ath10k
*ar
= hw
->priv
;
3514 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3515 struct ath10k_sta
*arsta
= (struct ath10k_sta
*)sta
->drv_priv
;
3519 if (old_state
== IEEE80211_STA_NOTEXIST
&&
3520 new_state
== IEEE80211_STA_NONE
) {
3521 memset(arsta
, 0, sizeof(*arsta
));
3522 arsta
->arvif
= arvif
;
3523 INIT_WORK(&arsta
->update_wk
, ath10k_sta_rc_update_wk
);
3526 /* cancel must be done outside the mutex to avoid deadlock */
3527 if ((old_state
== IEEE80211_STA_NONE
&&
3528 new_state
== IEEE80211_STA_NOTEXIST
))
3529 cancel_work_sync(&arsta
->update_wk
);
3531 mutex_lock(&ar
->conf_mutex
);
3533 if (old_state
== IEEE80211_STA_NOTEXIST
&&
3534 new_state
== IEEE80211_STA_NONE
&&
3535 vif
->type
!= NL80211_IFTYPE_STATION
) {
3537 * New station addition.
3539 if (test_bit(ATH10K_FW_FEATURE_WMI_10X
, ar
->fw_features
))
3540 max_num_peers
= TARGET_10X_NUM_PEERS_MAX
- 1;
3542 max_num_peers
= TARGET_NUM_PEERS
;
3544 if (ar
->num_peers
>= max_num_peers
) {
3545 ath10k_warn(ar
, "number of peers exceeded: peers number %d (max peers %d)\n",
3546 ar
->num_peers
, max_num_peers
);
3551 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3552 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3553 arvif
->vdev_id
, sta
->addr
, ar
->num_peers
);
3555 ret
= ath10k_peer_create(ar
, arvif
->vdev_id
, sta
->addr
);
3557 ath10k_warn(ar
, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3558 sta
->addr
, arvif
->vdev_id
, ret
);
3559 } else if ((old_state
== IEEE80211_STA_NONE
&&
3560 new_state
== IEEE80211_STA_NOTEXIST
)) {
3562 * Existing station deletion.
3564 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
3565 "mac vdev %d peer delete %pM (sta gone)\n",
3566 arvif
->vdev_id
, sta
->addr
);
3567 ret
= ath10k_peer_delete(ar
, arvif
->vdev_id
, sta
->addr
);
3569 ath10k_warn(ar
, "failed to delete peer %pM for vdev %d: %i\n",
3570 sta
->addr
, arvif
->vdev_id
, ret
);
3572 if (vif
->type
== NL80211_IFTYPE_STATION
)
3573 ath10k_bss_disassoc(hw
, vif
);
3574 } else if (old_state
== IEEE80211_STA_AUTH
&&
3575 new_state
== IEEE80211_STA_ASSOC
&&
3576 (vif
->type
== NL80211_IFTYPE_AP
||
3577 vif
->type
== NL80211_IFTYPE_ADHOC
)) {
3581 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac sta %pM associated\n",
3584 ret
= ath10k_station_assoc(ar
, vif
, sta
, false);
3586 ath10k_warn(ar
, "failed to associate station %pM for vdev %i: %i\n",
3587 sta
->addr
, arvif
->vdev_id
, ret
);
3588 } else if (old_state
== IEEE80211_STA_ASSOC
&&
3589 new_state
== IEEE80211_STA_AUTH
&&
3590 (vif
->type
== NL80211_IFTYPE_AP
||
3591 vif
->type
== NL80211_IFTYPE_ADHOC
)) {
3595 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac sta %pM disassociated\n",
3598 ret
= ath10k_station_disassoc(ar
, vif
, sta
);
3600 ath10k_warn(ar
, "failed to disassociate station: %pM vdev %i: %i\n",
3601 sta
->addr
, arvif
->vdev_id
, ret
);
3604 mutex_unlock(&ar
->conf_mutex
);
3608 static int ath10k_conf_tx_uapsd(struct ath10k
*ar
, struct ieee80211_vif
*vif
,
3609 u16 ac
, bool enable
)
3611 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3615 lockdep_assert_held(&ar
->conf_mutex
);
3617 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_STA
)
3621 case IEEE80211_AC_VO
:
3622 value
= WMI_STA_PS_UAPSD_AC3_DELIVERY_EN
|
3623 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN
;
3625 case IEEE80211_AC_VI
:
3626 value
= WMI_STA_PS_UAPSD_AC2_DELIVERY_EN
|
3627 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN
;
3629 case IEEE80211_AC_BE
:
3630 value
= WMI_STA_PS_UAPSD_AC1_DELIVERY_EN
|
3631 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN
;
3633 case IEEE80211_AC_BK
:
3634 value
= WMI_STA_PS_UAPSD_AC0_DELIVERY_EN
|
3635 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN
;
3640 arvif
->u
.sta
.uapsd
|= value
;
3642 arvif
->u
.sta
.uapsd
&= ~value
;
3644 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
3645 WMI_STA_PS_PARAM_UAPSD
,
3646 arvif
->u
.sta
.uapsd
);
3648 ath10k_warn(ar
, "failed to set uapsd params: %d\n", ret
);
3652 if (arvif
->u
.sta
.uapsd
)
3653 value
= WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD
;
3655 value
= WMI_STA_PS_RX_WAKE_POLICY_WAKE
;
3657 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
3658 WMI_STA_PS_PARAM_RX_WAKE_POLICY
,
3661 ath10k_warn(ar
, "failed to set rx wake param: %d\n", ret
);
3667 static int ath10k_conf_tx(struct ieee80211_hw
*hw
,
3668 struct ieee80211_vif
*vif
, u16 ac
,
3669 const struct ieee80211_tx_queue_params
*params
)
3671 struct ath10k
*ar
= hw
->priv
;
3672 struct wmi_wmm_params_arg
*p
= NULL
;
3675 mutex_lock(&ar
->conf_mutex
);
3678 case IEEE80211_AC_VO
:
3679 p
= &ar
->wmm_params
.ac_vo
;
3681 case IEEE80211_AC_VI
:
3682 p
= &ar
->wmm_params
.ac_vi
;
3684 case IEEE80211_AC_BE
:
3685 p
= &ar
->wmm_params
.ac_be
;
3687 case IEEE80211_AC_BK
:
3688 p
= &ar
->wmm_params
.ac_bk
;
3697 p
->cwmin
= params
->cw_min
;
3698 p
->cwmax
= params
->cw_max
;
3699 p
->aifs
= params
->aifs
;
3702 * The channel time duration programmed in the HW is in absolute
3703 * microseconds, while mac80211 gives the txop in units of
3706 p
->txop
= params
->txop
* 32;
3708 /* FIXME: FW accepts wmm params per hw, not per vif */
3709 ret
= ath10k_wmi_pdev_set_wmm_params(ar
, &ar
->wmm_params
);
3711 ath10k_warn(ar
, "failed to set wmm params: %d\n", ret
);
3715 ret
= ath10k_conf_tx_uapsd(ar
, vif
, ac
, params
->uapsd
);
3717 ath10k_warn(ar
, "failed to set sta uapsd: %d\n", ret
);
3720 mutex_unlock(&ar
->conf_mutex
);
3724 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3726 static int ath10k_remain_on_channel(struct ieee80211_hw
*hw
,
3727 struct ieee80211_vif
*vif
,
3728 struct ieee80211_channel
*chan
,
3730 enum ieee80211_roc_type type
)
3732 struct ath10k
*ar
= hw
->priv
;
3733 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3734 struct wmi_start_scan_arg arg
;
3737 mutex_lock(&ar
->conf_mutex
);
3739 spin_lock_bh(&ar
->data_lock
);
3740 switch (ar
->scan
.state
) {
3741 case ATH10K_SCAN_IDLE
:
3742 reinit_completion(&ar
->scan
.started
);
3743 reinit_completion(&ar
->scan
.completed
);
3744 reinit_completion(&ar
->scan
.on_channel
);
3745 ar
->scan
.state
= ATH10K_SCAN_STARTING
;
3746 ar
->scan
.is_roc
= true;
3747 ar
->scan
.vdev_id
= arvif
->vdev_id
;
3748 ar
->scan
.roc_freq
= chan
->center_freq
;
3751 case ATH10K_SCAN_STARTING
:
3752 case ATH10K_SCAN_RUNNING
:
3753 case ATH10K_SCAN_ABORTING
:
3757 spin_unlock_bh(&ar
->data_lock
);
3762 memset(&arg
, 0, sizeof(arg
));
3763 ath10k_wmi_start_scan_init(ar
, &arg
);
3764 arg
.vdev_id
= arvif
->vdev_id
;
3765 arg
.scan_id
= ATH10K_SCAN_ID
;
3767 arg
.channels
[0] = chan
->center_freq
;
3768 arg
.dwell_time_active
= duration
;
3769 arg
.dwell_time_passive
= duration
;
3770 arg
.max_scan_time
= 2 * duration
;
3771 arg
.scan_ctrl_flags
|= WMI_SCAN_FLAG_PASSIVE
;
3772 arg
.scan_ctrl_flags
|= WMI_SCAN_FILTER_PROBE_REQ
;
3774 ret
= ath10k_start_scan(ar
, &arg
);
3776 ath10k_warn(ar
, "failed to start roc scan: %d\n", ret
);
3777 spin_lock_bh(&ar
->data_lock
);
3778 ar
->scan
.state
= ATH10K_SCAN_IDLE
;
3779 spin_unlock_bh(&ar
->data_lock
);
3783 ret
= wait_for_completion_timeout(&ar
->scan
.on_channel
, 3*HZ
);
3785 ath10k_warn(ar
, "failed to switch to channel for roc scan\n");
3787 ret
= ath10k_scan_stop(ar
);
3789 ath10k_warn(ar
, "failed to stop scan: %d\n", ret
);
3797 mutex_unlock(&ar
->conf_mutex
);
3801 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw
*hw
)
3803 struct ath10k
*ar
= hw
->priv
;
3805 mutex_lock(&ar
->conf_mutex
);
3806 cancel_delayed_work_sync(&ar
->scan
.timeout
);
3807 ath10k_scan_abort(ar
);
3808 mutex_unlock(&ar
->conf_mutex
);
3814 * Both RTS and Fragmentation threshold are interface-specific
3815 * in ath10k, but device-specific in mac80211.
3818 static int ath10k_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
3820 struct ath10k
*ar
= hw
->priv
;
3821 struct ath10k_vif
*arvif
;
3824 mutex_lock(&ar
->conf_mutex
);
3825 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
3826 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d rts threshold %d\n",
3827 arvif
->vdev_id
, value
);
3829 ret
= ath10k_mac_set_rts(arvif
, value
);
3831 ath10k_warn(ar
, "failed to set rts threshold for vdev %d: %d\n",
3832 arvif
->vdev_id
, ret
);
3836 mutex_unlock(&ar
->conf_mutex
);
3841 static int ath10k_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
3843 struct ath10k
*ar
= hw
->priv
;
3844 struct ath10k_vif
*arvif
;
3847 mutex_lock(&ar
->conf_mutex
);
3848 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
3849 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d fragmentation threshold %d\n",
3850 arvif
->vdev_id
, value
);
3852 ret
= ath10k_mac_set_rts(arvif
, value
);
3854 ath10k_warn(ar
, "failed to set fragmentation threshold for vdev %d: %d\n",
3855 arvif
->vdev_id
, ret
);
3859 mutex_unlock(&ar
->conf_mutex
);
3864 static void ath10k_flush(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
3865 u32 queues
, bool drop
)
3867 struct ath10k
*ar
= hw
->priv
;
3871 /* mac80211 doesn't care if we really xmit queued frames or not
3872 * we'll collect those frames either way if we stop/delete vdevs */
3876 mutex_lock(&ar
->conf_mutex
);
3878 if (ar
->state
== ATH10K_STATE_WEDGED
)
3881 ret
= wait_event_timeout(ar
->htt
.empty_tx_wq
, ({
3884 spin_lock_bh(&ar
->htt
.tx_lock
);
3885 empty
= (ar
->htt
.num_pending_tx
== 0);
3886 spin_unlock_bh(&ar
->htt
.tx_lock
);
3888 skip
= (ar
->state
== ATH10K_STATE_WEDGED
);
3891 }), ATH10K_FLUSH_TIMEOUT_HZ
);
3893 if (ret
<= 0 || skip
)
3894 ath10k_warn(ar
, "failed to flush transmit queue (skip %i ar-state %i): %i\n",
3895 skip
, ar
->state
, ret
);
3898 mutex_unlock(&ar
->conf_mutex
);
3901 /* TODO: Implement this function properly
3902 * For now it is needed to reply to Probe Requests in IBSS mode.
3903 * Propably we need this information from FW.
3905 static int ath10k_tx_last_beacon(struct ieee80211_hw
*hw
)
3911 static int ath10k_suspend(struct ieee80211_hw
*hw
,
3912 struct cfg80211_wowlan
*wowlan
)
3914 struct ath10k
*ar
= hw
->priv
;
3917 mutex_lock(&ar
->conf_mutex
);
3919 ret
= ath10k_wait_for_suspend(ar
, WMI_PDEV_SUSPEND
);
3921 if (ret
== -ETIMEDOUT
)
3927 ret
= ath10k_hif_suspend(ar
);
3929 ath10k_warn(ar
, "failed to suspend hif: %d\n", ret
);
3936 ret
= ath10k_wmi_pdev_resume_target(ar
);
3938 ath10k_warn(ar
, "failed to resume target: %d\n", ret
);
3942 mutex_unlock(&ar
->conf_mutex
);
3946 static int ath10k_resume(struct ieee80211_hw
*hw
)
3948 struct ath10k
*ar
= hw
->priv
;
3951 mutex_lock(&ar
->conf_mutex
);
3953 ret
= ath10k_hif_resume(ar
);
3955 ath10k_warn(ar
, "failed to resume hif: %d\n", ret
);
3960 ret
= ath10k_wmi_pdev_resume_target(ar
);
3962 ath10k_warn(ar
, "failed to resume target: %d\n", ret
);
3969 mutex_unlock(&ar
->conf_mutex
);
3974 static void ath10k_restart_complete(struct ieee80211_hw
*hw
)
3976 struct ath10k
*ar
= hw
->priv
;
3978 mutex_lock(&ar
->conf_mutex
);
3980 /* If device failed to restart it will be in a different state, e.g.
3981 * ATH10K_STATE_WEDGED */
3982 if (ar
->state
== ATH10K_STATE_RESTARTED
) {
3983 ath10k_info(ar
, "device successfully recovered\n");
3984 ar
->state
= ATH10K_STATE_ON
;
3987 mutex_unlock(&ar
->conf_mutex
);
3990 static int ath10k_get_survey(struct ieee80211_hw
*hw
, int idx
,
3991 struct survey_info
*survey
)
3993 struct ath10k
*ar
= hw
->priv
;
3994 struct ieee80211_supported_band
*sband
;
3995 struct survey_info
*ar_survey
= &ar
->survey
[idx
];
3998 mutex_lock(&ar
->conf_mutex
);
4000 sband
= hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
];
4001 if (sband
&& idx
>= sband
->n_channels
) {
4002 idx
-= sband
->n_channels
;
4007 sband
= hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
];
4009 if (!sband
|| idx
>= sband
->n_channels
) {
4014 spin_lock_bh(&ar
->data_lock
);
4015 memcpy(survey
, ar_survey
, sizeof(*survey
));
4016 spin_unlock_bh(&ar
->data_lock
);
4018 survey
->channel
= &sband
->channels
[idx
];
4021 mutex_unlock(&ar
->conf_mutex
);
4025 /* Helper table for legacy fixed_rate/bitrate_mask */
4026 static const u8 cck_ofdm_rate
[] = {
4043 /* Check if only one bit set */
4044 static int ath10k_check_single_mask(u32 mask
)
4052 mask
&= ~BIT(bit
- 1);
4060 ath10k_default_bitrate_mask(struct ath10k
*ar
,
4061 enum ieee80211_band band
,
4062 const struct cfg80211_bitrate_mask
*mask
)
4064 u32 legacy
= 0x00ff;
4069 case IEEE80211_BAND_2GHZ
:
4073 case IEEE80211_BAND_5GHZ
:
4079 if (mask
->control
[band
].legacy
!= legacy
)
4082 for (i
= 0; i
< ar
->num_rf_chains
; i
++)
4083 if (mask
->control
[band
].ht_mcs
[i
] != ht
)
4086 for (i
= 0; i
< ar
->num_rf_chains
; i
++)
4087 if (mask
->control
[band
].vht_mcs
[i
] != vht
)
4094 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask
*mask
,
4095 enum ieee80211_band band
,
4098 int ht_nss
= 0, vht_nss
= 0, i
;
4101 if (ath10k_check_single_mask(mask
->control
[band
].legacy
))
4105 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++) {
4106 if (mask
->control
[band
].ht_mcs
[i
] == 0xff)
4108 else if (mask
->control
[band
].ht_mcs
[i
] == 0x00)
4117 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++) {
4118 if (mask
->control
[band
].vht_mcs
[i
] == 0x03ff)
4120 else if (mask
->control
[band
].vht_mcs
[i
] == 0x0000)
4128 if (ht_nss
> 0 && vht_nss
> 0)
4132 *fixed_nss
= ht_nss
;
4134 *fixed_nss
= vht_nss
;
4142 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask
*mask
,
4143 enum ieee80211_band band
,
4144 enum wmi_rate_preamble
*preamble
)
4146 int legacy
= 0, ht
= 0, vht
= 0, i
;
4148 *preamble
= WMI_RATE_PREAMBLE_OFDM
;
4151 legacy
= ath10k_check_single_mask(mask
->control
[band
].legacy
);
4156 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++)
4157 ht
+= ath10k_check_single_mask(mask
->control
[band
].ht_mcs
[i
]);
4162 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++)
4163 vht
+= ath10k_check_single_mask(mask
->control
[band
].vht_mcs
[i
]);
4167 /* Currently we support only one fixed_rate */
4168 if ((legacy
+ ht
+ vht
) != 1)
4172 *preamble
= WMI_RATE_PREAMBLE_HT
;
4174 *preamble
= WMI_RATE_PREAMBLE_VHT
;
4180 ath10k_bitrate_mask_rate(struct ath10k
*ar
,
4181 const struct cfg80211_bitrate_mask
*mask
,
4182 enum ieee80211_band band
,
4186 u8 rate
= 0, pream
= 0, nss
= 0, i
;
4187 enum wmi_rate_preamble preamble
;
4189 /* Check if single rate correct */
4190 if (!ath10k_bitrate_mask_correct(mask
, band
, &preamble
))
4196 case WMI_RATE_PREAMBLE_CCK
:
4197 case WMI_RATE_PREAMBLE_OFDM
:
4198 i
= ffs(mask
->control
[band
].legacy
) - 1;
4200 if (band
== IEEE80211_BAND_2GHZ
&& i
< 4)
4201 pream
= WMI_RATE_PREAMBLE_CCK
;
4203 if (band
== IEEE80211_BAND_5GHZ
)
4206 if (i
>= ARRAY_SIZE(cck_ofdm_rate
))
4209 rate
= cck_ofdm_rate
[i
];
4211 case WMI_RATE_PREAMBLE_HT
:
4212 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++)
4213 if (mask
->control
[band
].ht_mcs
[i
])
4216 if (i
== IEEE80211_HT_MCS_MASK_LEN
)
4219 rate
= ffs(mask
->control
[band
].ht_mcs
[i
]) - 1;
4222 case WMI_RATE_PREAMBLE_VHT
:
4223 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++)
4224 if (mask
->control
[band
].vht_mcs
[i
])
4227 if (i
== NL80211_VHT_NSS_MAX
)
4230 rate
= ffs(mask
->control
[band
].vht_mcs
[i
]) - 1;
4235 *fixed_nss
= nss
+ 1;
4239 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4242 *fixed_rate
= pream
| nss
| rate
;
4247 static bool ath10k_get_fixed_rate_nss(struct ath10k
*ar
,
4248 const struct cfg80211_bitrate_mask
*mask
,
4249 enum ieee80211_band band
,
4253 /* First check full NSS mask, if we can simply limit NSS */
4254 if (ath10k_bitrate_mask_nss(mask
, band
, fixed_nss
))
4257 /* Next Check single rate is set */
4258 return ath10k_bitrate_mask_rate(ar
, mask
, band
, fixed_rate
, fixed_nss
);
4261 static int ath10k_set_fixed_rate_param(struct ath10k_vif
*arvif
,
4266 struct ath10k
*ar
= arvif
->ar
;
4270 mutex_lock(&ar
->conf_mutex
);
4272 if (arvif
->fixed_rate
== fixed_rate
&&
4273 arvif
->fixed_nss
== fixed_nss
&&
4274 arvif
->force_sgi
== force_sgi
)
4277 if (fixed_rate
== WMI_FIXED_RATE_NONE
)
4278 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac disable fixed bitrate mask\n");
4281 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac force sgi\n");
4283 vdev_param
= ar
->wmi
.vdev_param
->fixed_rate
;
4284 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
,
4285 vdev_param
, fixed_rate
);
4287 ath10k_warn(ar
, "failed to set fixed rate param 0x%02x: %d\n",
4293 arvif
->fixed_rate
= fixed_rate
;
4295 vdev_param
= ar
->wmi
.vdev_param
->nss
;
4296 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
,
4297 vdev_param
, fixed_nss
);
4300 ath10k_warn(ar
, "failed to set fixed nss param %d: %d\n",
4306 arvif
->fixed_nss
= fixed_nss
;
4308 vdev_param
= ar
->wmi
.vdev_param
->sgi
;
4309 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4313 ath10k_warn(ar
, "failed to set sgi param %d: %d\n",
4319 arvif
->force_sgi
= force_sgi
;
4322 mutex_unlock(&ar
->conf_mutex
);
4326 static int ath10k_set_bitrate_mask(struct ieee80211_hw
*hw
,
4327 struct ieee80211_vif
*vif
,
4328 const struct cfg80211_bitrate_mask
*mask
)
4330 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
4331 struct ath10k
*ar
= arvif
->ar
;
4332 enum ieee80211_band band
= ar
->hw
->conf
.chandef
.chan
->band
;
4333 u8 fixed_rate
= WMI_FIXED_RATE_NONE
;
4334 u8 fixed_nss
= ar
->num_rf_chains
;
4337 force_sgi
= mask
->control
[band
].gi
;
4338 if (force_sgi
== NL80211_TXRATE_FORCE_LGI
)
4341 if (!ath10k_default_bitrate_mask(ar
, band
, mask
)) {
4342 if (!ath10k_get_fixed_rate_nss(ar
, mask
, band
,
4348 if (fixed_rate
== WMI_FIXED_RATE_NONE
&& force_sgi
) {
4349 ath10k_warn(ar
, "failed to force SGI usage for default rate settings\n");
4353 return ath10k_set_fixed_rate_param(arvif
, fixed_rate
,
4354 fixed_nss
, force_sgi
);
4357 static void ath10k_sta_rc_update(struct ieee80211_hw
*hw
,
4358 struct ieee80211_vif
*vif
,
4359 struct ieee80211_sta
*sta
,
4362 struct ath10k
*ar
= hw
->priv
;
4363 struct ath10k_sta
*arsta
= (struct ath10k_sta
*)sta
->drv_priv
;
4366 spin_lock_bh(&ar
->data_lock
);
4368 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
4369 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4370 sta
->addr
, changed
, sta
->bandwidth
, sta
->rx_nss
,
4373 if (changed
& IEEE80211_RC_BW_CHANGED
) {
4374 bw
= WMI_PEER_CHWIDTH_20MHZ
;
4376 switch (sta
->bandwidth
) {
4377 case IEEE80211_STA_RX_BW_20
:
4378 bw
= WMI_PEER_CHWIDTH_20MHZ
;
4380 case IEEE80211_STA_RX_BW_40
:
4381 bw
= WMI_PEER_CHWIDTH_40MHZ
;
4383 case IEEE80211_STA_RX_BW_80
:
4384 bw
= WMI_PEER_CHWIDTH_80MHZ
;
4386 case IEEE80211_STA_RX_BW_160
:
4387 ath10k_warn(ar
, "Invalid bandwith %d in rc update for %pM\n",
4388 sta
->bandwidth
, sta
->addr
);
4389 bw
= WMI_PEER_CHWIDTH_20MHZ
;
4396 if (changed
& IEEE80211_RC_NSS_CHANGED
)
4397 arsta
->nss
= sta
->rx_nss
;
4399 if (changed
& IEEE80211_RC_SMPS_CHANGED
) {
4400 smps
= WMI_PEER_SMPS_PS_NONE
;
4402 switch (sta
->smps_mode
) {
4403 case IEEE80211_SMPS_AUTOMATIC
:
4404 case IEEE80211_SMPS_OFF
:
4405 smps
= WMI_PEER_SMPS_PS_NONE
;
4407 case IEEE80211_SMPS_STATIC
:
4408 smps
= WMI_PEER_SMPS_STATIC
;
4410 case IEEE80211_SMPS_DYNAMIC
:
4411 smps
= WMI_PEER_SMPS_DYNAMIC
;
4413 case IEEE80211_SMPS_NUM_MODES
:
4414 ath10k_warn(ar
, "Invalid smps %d in sta rc update for %pM\n",
4415 sta
->smps_mode
, sta
->addr
);
4416 smps
= WMI_PEER_SMPS_PS_NONE
;
4423 arsta
->changed
|= changed
;
4425 spin_unlock_bh(&ar
->data_lock
);
4427 ieee80211_queue_work(hw
, &arsta
->update_wk
);
4430 static u64
ath10k_get_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
4433 * FIXME: Return 0 for time being. Need to figure out whether FW
4434 * has the API to fetch 64-bit local TSF
4440 static int ath10k_ampdu_action(struct ieee80211_hw
*hw
,
4441 struct ieee80211_vif
*vif
,
4442 enum ieee80211_ampdu_mlme_action action
,
4443 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
4446 struct ath10k
*ar
= hw
->priv
;
4447 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
4449 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
4450 arvif
->vdev_id
, sta
->addr
, tid
, action
);
4453 case IEEE80211_AMPDU_RX_START
:
4454 case IEEE80211_AMPDU_RX_STOP
:
4455 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
4456 * creation/removal. Do we need to verify this?
4459 case IEEE80211_AMPDU_TX_START
:
4460 case IEEE80211_AMPDU_TX_STOP_CONT
:
4461 case IEEE80211_AMPDU_TX_STOP_FLUSH
:
4462 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT
:
4463 case IEEE80211_AMPDU_TX_OPERATIONAL
:
4464 /* Firmware offloads Tx aggregation entirely so deny mac80211
4465 * Tx aggregation requests.
4473 static const struct ieee80211_ops ath10k_ops
= {
4475 .start
= ath10k_start
,
4476 .stop
= ath10k_stop
,
4477 .config
= ath10k_config
,
4478 .add_interface
= ath10k_add_interface
,
4479 .remove_interface
= ath10k_remove_interface
,
4480 .configure_filter
= ath10k_configure_filter
,
4481 .bss_info_changed
= ath10k_bss_info_changed
,
4482 .hw_scan
= ath10k_hw_scan
,
4483 .cancel_hw_scan
= ath10k_cancel_hw_scan
,
4484 .set_key
= ath10k_set_key
,
4485 .sta_state
= ath10k_sta_state
,
4486 .conf_tx
= ath10k_conf_tx
,
4487 .remain_on_channel
= ath10k_remain_on_channel
,
4488 .cancel_remain_on_channel
= ath10k_cancel_remain_on_channel
,
4489 .set_rts_threshold
= ath10k_set_rts_threshold
,
4490 .set_frag_threshold
= ath10k_set_frag_threshold
,
4491 .flush
= ath10k_flush
,
4492 .tx_last_beacon
= ath10k_tx_last_beacon
,
4493 .set_antenna
= ath10k_set_antenna
,
4494 .get_antenna
= ath10k_get_antenna
,
4495 .restart_complete
= ath10k_restart_complete
,
4496 .get_survey
= ath10k_get_survey
,
4497 .set_bitrate_mask
= ath10k_set_bitrate_mask
,
4498 .sta_rc_update
= ath10k_sta_rc_update
,
4499 .get_tsf
= ath10k_get_tsf
,
4500 .ampdu_action
= ath10k_ampdu_action
,
4501 .get_et_sset_count
= ath10k_debug_get_et_sset_count
,
4502 .get_et_stats
= ath10k_debug_get_et_stats
,
4503 .get_et_strings
= ath10k_debug_get_et_strings
,
4505 CFG80211_TESTMODE_CMD(ath10k_tm_cmd
)
4508 .suspend
= ath10k_suspend
,
4509 .resume
= ath10k_resume
,
4513 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4514 .bitrate = (_rate), \
4515 .flags = (_flags), \
4516 .hw_value = (_rateid), \
4519 #define CHAN2G(_channel, _freq, _flags) { \
4520 .band = IEEE80211_BAND_2GHZ, \
4521 .hw_value = (_channel), \
4522 .center_freq = (_freq), \
4523 .flags = (_flags), \
4524 .max_antenna_gain = 0, \
4528 #define CHAN5G(_channel, _freq, _flags) { \
4529 .band = IEEE80211_BAND_5GHZ, \
4530 .hw_value = (_channel), \
4531 .center_freq = (_freq), \
4532 .flags = (_flags), \
4533 .max_antenna_gain = 0, \
4537 static const struct ieee80211_channel ath10k_2ghz_channels
[] = {
4547 CHAN2G(10, 2457, 0),
4548 CHAN2G(11, 2462, 0),
4549 CHAN2G(12, 2467, 0),
4550 CHAN2G(13, 2472, 0),
4551 CHAN2G(14, 2484, 0),
4554 static const struct ieee80211_channel ath10k_5ghz_channels
[] = {
4555 CHAN5G(36, 5180, 0),
4556 CHAN5G(40, 5200, 0),
4557 CHAN5G(44, 5220, 0),
4558 CHAN5G(48, 5240, 0),
4559 CHAN5G(52, 5260, 0),
4560 CHAN5G(56, 5280, 0),
4561 CHAN5G(60, 5300, 0),
4562 CHAN5G(64, 5320, 0),
4563 CHAN5G(100, 5500, 0),
4564 CHAN5G(104, 5520, 0),
4565 CHAN5G(108, 5540, 0),
4566 CHAN5G(112, 5560, 0),
4567 CHAN5G(116, 5580, 0),
4568 CHAN5G(120, 5600, 0),
4569 CHAN5G(124, 5620, 0),
4570 CHAN5G(128, 5640, 0),
4571 CHAN5G(132, 5660, 0),
4572 CHAN5G(136, 5680, 0),
4573 CHAN5G(140, 5700, 0),
4574 CHAN5G(149, 5745, 0),
4575 CHAN5G(153, 5765, 0),
4576 CHAN5G(157, 5785, 0),
4577 CHAN5G(161, 5805, 0),
4578 CHAN5G(165, 5825, 0),
4581 static struct ieee80211_rate ath10k_rates
[] = {
4583 RATETAB_ENT(10, 0x82, 0),
4584 RATETAB_ENT(20, 0x84, 0),
4585 RATETAB_ENT(55, 0x8b, 0),
4586 RATETAB_ENT(110, 0x96, 0),
4588 RATETAB_ENT(60, 0x0c, 0),
4589 RATETAB_ENT(90, 0x12, 0),
4590 RATETAB_ENT(120, 0x18, 0),
4591 RATETAB_ENT(180, 0x24, 0),
4592 RATETAB_ENT(240, 0x30, 0),
4593 RATETAB_ENT(360, 0x48, 0),
4594 RATETAB_ENT(480, 0x60, 0),
4595 RATETAB_ENT(540, 0x6c, 0),
4598 #define ath10k_a_rates (ath10k_rates + 4)
4599 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4600 #define ath10k_g_rates (ath10k_rates + 0)
4601 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4603 struct ath10k
*ath10k_mac_create(size_t priv_size
)
4605 struct ieee80211_hw
*hw
;
4608 hw
= ieee80211_alloc_hw(sizeof(struct ath10k
) + priv_size
, &ath10k_ops
);
4618 void ath10k_mac_destroy(struct ath10k
*ar
)
4620 ieee80211_free_hw(ar
->hw
);
4623 static const struct ieee80211_iface_limit ath10k_if_limits
[] = {
4626 .types
= BIT(NL80211_IFTYPE_STATION
)
4627 | BIT(NL80211_IFTYPE_P2P_CLIENT
)
4631 .types
= BIT(NL80211_IFTYPE_P2P_GO
)
4635 .types
= BIT(NL80211_IFTYPE_AP
)
4639 static const struct ieee80211_iface_limit ath10k_10x_if_limits
[] = {
4642 .types
= BIT(NL80211_IFTYPE_AP
)
4646 static const struct ieee80211_iface_combination ath10k_if_comb
[] = {
4648 .limits
= ath10k_if_limits
,
4649 .n_limits
= ARRAY_SIZE(ath10k_if_limits
),
4650 .max_interfaces
= 8,
4651 .num_different_channels
= 1,
4652 .beacon_int_infra_match
= true,
4656 static const struct ieee80211_iface_combination ath10k_10x_if_comb
[] = {
4658 .limits
= ath10k_10x_if_limits
,
4659 .n_limits
= ARRAY_SIZE(ath10k_10x_if_limits
),
4660 .max_interfaces
= 8,
4661 .num_different_channels
= 1,
4662 .beacon_int_infra_match
= true,
4663 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4664 .radar_detect_widths
= BIT(NL80211_CHAN_WIDTH_20_NOHT
) |
4665 BIT(NL80211_CHAN_WIDTH_20
) |
4666 BIT(NL80211_CHAN_WIDTH_40
) |
4667 BIT(NL80211_CHAN_WIDTH_80
),
4672 static struct ieee80211_sta_vht_cap
ath10k_create_vht_cap(struct ath10k
*ar
)
4674 struct ieee80211_sta_vht_cap vht_cap
= {0};
4678 vht_cap
.vht_supported
= 1;
4679 vht_cap
.cap
= ar
->vht_cap_info
;
4682 for (i
= 0; i
< 8; i
++) {
4683 if (i
< ar
->num_rf_chains
)
4684 mcs_map
|= IEEE80211_VHT_MCS_SUPPORT_0_9
<< (i
*2);
4686 mcs_map
|= IEEE80211_VHT_MCS_NOT_SUPPORTED
<< (i
*2);
4689 vht_cap
.vht_mcs
.rx_mcs_map
= cpu_to_le16(mcs_map
);
4690 vht_cap
.vht_mcs
.tx_mcs_map
= cpu_to_le16(mcs_map
);
4695 static struct ieee80211_sta_ht_cap
ath10k_get_ht_cap(struct ath10k
*ar
)
4698 struct ieee80211_sta_ht_cap ht_cap
= {0};
4700 if (!(ar
->ht_cap_info
& WMI_HT_CAP_ENABLED
))
4703 ht_cap
.ht_supported
= 1;
4704 ht_cap
.ampdu_factor
= IEEE80211_HT_MAX_AMPDU_64K
;
4705 ht_cap
.ampdu_density
= IEEE80211_HT_MPDU_DENSITY_8
;
4706 ht_cap
.cap
|= IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
4707 ht_cap
.cap
|= IEEE80211_HT_CAP_DSSSCCK40
;
4708 ht_cap
.cap
|= WLAN_HT_CAP_SM_PS_STATIC
<< IEEE80211_HT_CAP_SM_PS_SHIFT
;
4710 if (ar
->ht_cap_info
& WMI_HT_CAP_HT20_SGI
)
4711 ht_cap
.cap
|= IEEE80211_HT_CAP_SGI_20
;
4713 if (ar
->ht_cap_info
& WMI_HT_CAP_HT40_SGI
)
4714 ht_cap
.cap
|= IEEE80211_HT_CAP_SGI_40
;
4716 if (ar
->ht_cap_info
& WMI_HT_CAP_DYNAMIC_SMPS
) {
4719 smps
= WLAN_HT_CAP_SM_PS_DYNAMIC
;
4720 smps
<<= IEEE80211_HT_CAP_SM_PS_SHIFT
;
4725 if (ar
->ht_cap_info
& WMI_HT_CAP_TX_STBC
)
4726 ht_cap
.cap
|= IEEE80211_HT_CAP_TX_STBC
;
4728 if (ar
->ht_cap_info
& WMI_HT_CAP_RX_STBC
) {
4731 stbc
= ar
->ht_cap_info
;
4732 stbc
&= WMI_HT_CAP_RX_STBC
;
4733 stbc
>>= WMI_HT_CAP_RX_STBC_MASK_SHIFT
;
4734 stbc
<<= IEEE80211_HT_CAP_RX_STBC_SHIFT
;
4735 stbc
&= IEEE80211_HT_CAP_RX_STBC
;
4740 if (ar
->ht_cap_info
& WMI_HT_CAP_LDPC
)
4741 ht_cap
.cap
|= IEEE80211_HT_CAP_LDPC_CODING
;
4743 if (ar
->ht_cap_info
& WMI_HT_CAP_L_SIG_TXOP_PROT
)
4744 ht_cap
.cap
|= IEEE80211_HT_CAP_LSIG_TXOP_PROT
;
4746 /* max AMSDU is implicitly taken from vht_cap_info */
4747 if (ar
->vht_cap_info
& WMI_VHT_CAP_MAX_MPDU_LEN_MASK
)
4748 ht_cap
.cap
|= IEEE80211_HT_CAP_MAX_AMSDU
;
4750 for (i
= 0; i
< ar
->num_rf_chains
; i
++)
4751 ht_cap
.mcs
.rx_mask
[i
] = 0xFF;
4753 ht_cap
.mcs
.tx_params
|= IEEE80211_HT_MCS_TX_DEFINED
;
4758 static void ath10k_get_arvif_iter(void *data
, u8
*mac
,
4759 struct ieee80211_vif
*vif
)
4761 struct ath10k_vif_iter
*arvif_iter
= data
;
4762 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
4764 if (arvif
->vdev_id
== arvif_iter
->vdev_id
)
4765 arvif_iter
->arvif
= arvif
;
4768 struct ath10k_vif
*ath10k_get_arvif(struct ath10k
*ar
, u32 vdev_id
)
4770 struct ath10k_vif_iter arvif_iter
;
4773 memset(&arvif_iter
, 0, sizeof(struct ath10k_vif_iter
));
4774 arvif_iter
.vdev_id
= vdev_id
;
4776 flags
= IEEE80211_IFACE_ITER_RESUME_ALL
;
4777 ieee80211_iterate_active_interfaces_atomic(ar
->hw
,
4779 ath10k_get_arvif_iter
,
4781 if (!arvif_iter
.arvif
) {
4782 ath10k_warn(ar
, "No VIF found for vdev %d\n", vdev_id
);
4786 return arvif_iter
.arvif
;
4789 int ath10k_mac_register(struct ath10k
*ar
)
4791 struct ieee80211_supported_band
*band
;
4792 struct ieee80211_sta_vht_cap vht_cap
;
4793 struct ieee80211_sta_ht_cap ht_cap
;
4797 SET_IEEE80211_PERM_ADDR(ar
->hw
, ar
->mac_addr
);
4799 SET_IEEE80211_DEV(ar
->hw
, ar
->dev
);
4801 ht_cap
= ath10k_get_ht_cap(ar
);
4802 vht_cap
= ath10k_create_vht_cap(ar
);
4804 if (ar
->phy_capability
& WHAL_WLAN_11G_CAPABILITY
) {
4805 channels
= kmemdup(ath10k_2ghz_channels
,
4806 sizeof(ath10k_2ghz_channels
),
4813 band
= &ar
->mac
.sbands
[IEEE80211_BAND_2GHZ
];
4814 band
->n_channels
= ARRAY_SIZE(ath10k_2ghz_channels
);
4815 band
->channels
= channels
;
4816 band
->n_bitrates
= ath10k_g_rates_size
;
4817 band
->bitrates
= ath10k_g_rates
;
4818 band
->ht_cap
= ht_cap
;
4820 /* vht is not supported in 2.4 GHz */
4822 ar
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = band
;
4825 if (ar
->phy_capability
& WHAL_WLAN_11A_CAPABILITY
) {
4826 channels
= kmemdup(ath10k_5ghz_channels
,
4827 sizeof(ath10k_5ghz_channels
),
4834 band
= &ar
->mac
.sbands
[IEEE80211_BAND_5GHZ
];
4835 band
->n_channels
= ARRAY_SIZE(ath10k_5ghz_channels
);
4836 band
->channels
= channels
;
4837 band
->n_bitrates
= ath10k_a_rates_size
;
4838 band
->bitrates
= ath10k_a_rates
;
4839 band
->ht_cap
= ht_cap
;
4840 band
->vht_cap
= vht_cap
;
4841 ar
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] = band
;
4844 ar
->hw
->wiphy
->interface_modes
=
4845 BIT(NL80211_IFTYPE_STATION
) |
4846 BIT(NL80211_IFTYPE_AP
);
4848 ar
->hw
->wiphy
->available_antennas_rx
= ar
->supp_rx_chainmask
;
4849 ar
->hw
->wiphy
->available_antennas_tx
= ar
->supp_tx_chainmask
;
4851 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P
, ar
->fw_features
))
4852 ar
->hw
->wiphy
->interface_modes
|=
4853 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
4854 BIT(NL80211_IFTYPE_P2P_GO
);
4856 ar
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
4857 IEEE80211_HW_SUPPORTS_PS
|
4858 IEEE80211_HW_SUPPORTS_DYNAMIC_PS
|
4859 IEEE80211_HW_SUPPORTS_UAPSD
|
4860 IEEE80211_HW_MFP_CAPABLE
|
4861 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
4862 IEEE80211_HW_HAS_RATE_CONTROL
|
4863 IEEE80211_HW_SUPPORTS_STATIC_SMPS
|
4864 IEEE80211_HW_AP_LINK_PS
|
4865 IEEE80211_HW_SPECTRUM_MGMT
;
4867 /* MSDU can have HTT TX fragment pushed in front. The additional 4
4868 * bytes is used for padding/alignment if necessary. */
4869 ar
->hw
->extra_tx_headroom
+= sizeof(struct htt_data_tx_desc_frag
)*2 + 4;
4871 if (ar
->ht_cap_info
& WMI_HT_CAP_DYNAMIC_SMPS
)
4872 ar
->hw
->flags
|= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS
;
4874 if (ar
->ht_cap_info
& WMI_HT_CAP_ENABLED
) {
4875 ar
->hw
->flags
|= IEEE80211_HW_AMPDU_AGGREGATION
;
4876 ar
->hw
->flags
|= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW
;
4879 ar
->hw
->wiphy
->max_scan_ssids
= WLAN_SCAN_PARAMS_MAX_SSID
;
4880 ar
->hw
->wiphy
->max_scan_ie_len
= WLAN_SCAN_PARAMS_MAX_IE_LEN
;
4882 ar
->hw
->vif_data_size
= sizeof(struct ath10k_vif
);
4883 ar
->hw
->sta_data_size
= sizeof(struct ath10k_sta
);
4885 ar
->hw
->max_listen_interval
= ATH10K_MAX_HW_LISTEN_INTERVAL
;
4887 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
;
4888 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_HAS_CHANNEL_SWITCH
;
4889 ar
->hw
->wiphy
->max_remain_on_channel_duration
= 5000;
4891 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_UAPSD
;
4893 * on LL hardware queues are managed entirely by the FW
4894 * so we only advertise to mac we can do the queues thing
4898 if (test_bit(ATH10K_FW_FEATURE_WMI_10X
, ar
->fw_features
)) {
4899 ar
->hw
->wiphy
->iface_combinations
= ath10k_10x_if_comb
;
4900 ar
->hw
->wiphy
->n_iface_combinations
=
4901 ARRAY_SIZE(ath10k_10x_if_comb
);
4903 ar
->hw
->wiphy
->iface_combinations
= ath10k_if_comb
;
4904 ar
->hw
->wiphy
->n_iface_combinations
=
4905 ARRAY_SIZE(ath10k_if_comb
);
4907 ar
->hw
->wiphy
->interface_modes
|= BIT(NL80211_IFTYPE_ADHOC
);
4910 ar
->hw
->netdev_features
= NETIF_F_HW_CSUM
;
4912 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
)) {
4913 /* Init ath dfs pattern detector */
4914 ar
->ath_common
.debug_mask
= ATH_DBG_DFS
;
4915 ar
->dfs_detector
= dfs_pattern_detector_init(&ar
->ath_common
,
4918 if (!ar
->dfs_detector
)
4919 ath10k_warn(ar
, "failed to initialise DFS pattern detector\n");
4922 ret
= ath_regd_init(&ar
->ath_common
.regulatory
, ar
->hw
->wiphy
,
4923 ath10k_reg_notifier
);
4925 ath10k_err(ar
, "failed to initialise regulatory: %i\n", ret
);
4929 ret
= ieee80211_register_hw(ar
->hw
);
4931 ath10k_err(ar
, "failed to register ieee80211: %d\n", ret
);
4935 if (!ath_is_world_regd(&ar
->ath_common
.regulatory
)) {
4936 ret
= regulatory_hint(ar
->hw
->wiphy
,
4937 ar
->ath_common
.regulatory
.alpha2
);
4939 goto err_unregister
;
4945 ieee80211_unregister_hw(ar
->hw
);
4947 kfree(ar
->mac
.sbands
[IEEE80211_BAND_2GHZ
].channels
);
4948 kfree(ar
->mac
.sbands
[IEEE80211_BAND_5GHZ
].channels
);
4953 void ath10k_mac_unregister(struct ath10k
*ar
)
4955 ieee80211_unregister_hw(ar
->hw
);
4957 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
) && ar
->dfs_detector
)
4958 ar
->dfs_detector
->exit(ar
->dfs_detector
);
4960 kfree(ar
->mac
.sbands
[IEEE80211_BAND_2GHZ
].channels
);
4961 kfree(ar
->mac
.sbands
[IEEE80211_BAND_5GHZ
].channels
);
4963 SET_IEEE80211_DEV(ar
->hw
, NULL
);