2 * Copyright (c) 2004-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2012 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.
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/moduleparam.h>
21 #include <linux/inetdevice.h>
22 #include <linux/export.h>
23 #include <linux/sched/signal.h>
31 #define RATETAB_ENT(_rate, _rateid, _flags) { \
34 .hw_value = (_rateid), \
37 #define CHAN2G(_channel, _freq, _flags) { \
38 .band = NL80211_BAND_2GHZ, \
39 .hw_value = (_channel), \
40 .center_freq = (_freq), \
42 .max_antenna_gain = 0, \
46 #define CHAN5G(_channel, _flags) { \
47 .band = NL80211_BAND_5GHZ, \
48 .hw_value = (_channel), \
49 .center_freq = 5000 + (5 * (_channel)), \
51 .max_antenna_gain = 0, \
55 #define DEFAULT_BG_SCAN_PERIOD 60
57 struct ath6kl_cfg80211_match_probe_ssid {
58 struct cfg80211_ssid ssid;
62 static struct ieee80211_rate ath6kl_rates[] = {
63 RATETAB_ENT(10, 0x1, 0),
64 RATETAB_ENT(20, 0x2, 0),
65 RATETAB_ENT(55, 0x4, 0),
66 RATETAB_ENT(110, 0x8, 0),
67 RATETAB_ENT(60, 0x10, 0),
68 RATETAB_ENT(90, 0x20, 0),
69 RATETAB_ENT(120, 0x40, 0),
70 RATETAB_ENT(180, 0x80, 0),
71 RATETAB_ENT(240, 0x100, 0),
72 RATETAB_ENT(360, 0x200, 0),
73 RATETAB_ENT(480, 0x400, 0),
74 RATETAB_ENT(540, 0x800, 0),
77 #define ath6kl_a_rates (ath6kl_rates + 4)
78 #define ath6kl_a_rates_size 8
79 #define ath6kl_g_rates (ath6kl_rates + 0)
80 #define ath6kl_g_rates_size 12
82 #define ath6kl_g_htcap IEEE80211_HT_CAP_SGI_20
83 #define ath6kl_a_htcap (IEEE80211_HT_CAP_SUP_WIDTH_20_40 | \
84 IEEE80211_HT_CAP_SGI_20 | \
85 IEEE80211_HT_CAP_SGI_40)
87 static struct ieee80211_channel ath6kl_2ghz_channels[] = {
104 static struct ieee80211_channel ath6kl_5ghz_a_channels[] = {
105 CHAN5G(36, 0), CHAN5G(40, 0),
106 CHAN5G(44, 0), CHAN5G(48, 0),
107 CHAN5G(52, 0), CHAN5G(56, 0),
108 CHAN5G(60, 0), CHAN5G(64, 0),
109 CHAN5G(100, 0), CHAN5G(104, 0),
110 CHAN5G(108, 0), CHAN5G(112, 0),
111 CHAN5G(116, 0), CHAN5G(120, 0),
112 CHAN5G(124, 0), CHAN5G(128, 0),
113 CHAN5G(132, 0), CHAN5G(136, 0),
114 CHAN5G(140, 0), CHAN5G(149, 0),
115 CHAN5G(153, 0), CHAN5G(157, 0),
116 CHAN5G(161, 0), CHAN5G(165, 0),
117 CHAN5G(184, 0), CHAN5G(188, 0),
118 CHAN5G(192, 0), CHAN5G(196, 0),
119 CHAN5G(200, 0), CHAN5G(204, 0),
120 CHAN5G(208, 0), CHAN5G(212, 0),
124 static struct ieee80211_supported_band ath6kl_band_2ghz = {
125 .n_channels = ARRAY_SIZE(ath6kl_2ghz_channels),
126 .channels = ath6kl_2ghz_channels,
127 .n_bitrates = ath6kl_g_rates_size,
128 .bitrates = ath6kl_g_rates,
129 .ht_cap.cap = ath6kl_g_htcap,
130 .ht_cap.ht_supported = true,
133 static struct ieee80211_supported_band ath6kl_band_5ghz = {
134 .n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels),
135 .channels = ath6kl_5ghz_a_channels,
136 .n_bitrates = ath6kl_a_rates_size,
137 .bitrates = ath6kl_a_rates,
138 .ht_cap.cap = ath6kl_a_htcap,
139 .ht_cap.ht_supported = true,
142 #define CCKM_KRK_CIPHER_SUITE 0x004096ff /* use for KRK */
144 /* returns true if scheduled scan was stopped */
145 static bool __ath6kl_cfg80211_sscan_stop(struct ath6kl_vif *vif)
147 struct ath6kl *ar = vif->ar;
149 if (!test_and_clear_bit(SCHED_SCANNING, &vif->flags))
152 del_timer_sync(&vif->sched_scan_timer);
154 if (ar->state == ATH6KL_STATE_RECOVERY)
157 ath6kl_wmi_enable_sched_scan_cmd(ar->wmi, vif->fw_vif_idx, false);
162 static void ath6kl_cfg80211_sscan_disable(struct ath6kl_vif *vif)
164 struct ath6kl *ar = vif->ar;
167 stopped = __ath6kl_cfg80211_sscan_stop(vif);
172 cfg80211_sched_scan_stopped(ar->wiphy);
175 static int ath6kl_set_wpa_version(struct ath6kl_vif *vif,
176 enum nl80211_wpa_versions wpa_version)
178 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
181 vif->auth_mode = NONE_AUTH;
182 } else if (wpa_version & NL80211_WPA_VERSION_2) {
183 vif->auth_mode = WPA2_AUTH;
184 } else if (wpa_version & NL80211_WPA_VERSION_1) {
185 vif->auth_mode = WPA_AUTH;
187 ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
194 static int ath6kl_set_auth_type(struct ath6kl_vif *vif,
195 enum nl80211_auth_type auth_type)
197 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
200 case NL80211_AUTHTYPE_OPEN_SYSTEM:
201 vif->dot11_auth_mode = OPEN_AUTH;
203 case NL80211_AUTHTYPE_SHARED_KEY:
204 vif->dot11_auth_mode = SHARED_AUTH;
206 case NL80211_AUTHTYPE_NETWORK_EAP:
207 vif->dot11_auth_mode = LEAP_AUTH;
210 case NL80211_AUTHTYPE_AUTOMATIC:
211 vif->dot11_auth_mode = OPEN_AUTH | SHARED_AUTH;
215 ath6kl_err("%s: 0x%x not supported\n", __func__, auth_type);
222 static int ath6kl_set_cipher(struct ath6kl_vif *vif, u32 cipher, bool ucast)
224 u8 *ar_cipher = ucast ? &vif->prwise_crypto : &vif->grp_crypto;
225 u8 *ar_cipher_len = ucast ? &vif->prwise_crypto_len :
226 &vif->grp_crypto_len;
228 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
229 __func__, cipher, ucast);
233 /* our own hack to use value 0 as no crypto used */
234 *ar_cipher = NONE_CRYPT;
237 case WLAN_CIPHER_SUITE_WEP40:
238 *ar_cipher = WEP_CRYPT;
241 case WLAN_CIPHER_SUITE_WEP104:
242 *ar_cipher = WEP_CRYPT;
245 case WLAN_CIPHER_SUITE_TKIP:
246 *ar_cipher = TKIP_CRYPT;
249 case WLAN_CIPHER_SUITE_CCMP:
250 *ar_cipher = AES_CRYPT;
253 case WLAN_CIPHER_SUITE_SMS4:
254 *ar_cipher = WAPI_CRYPT;
258 ath6kl_err("cipher 0x%x not supported\n", cipher);
265 static void ath6kl_set_key_mgmt(struct ath6kl_vif *vif, u32 key_mgmt)
267 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
269 if (key_mgmt == WLAN_AKM_SUITE_PSK) {
270 if (vif->auth_mode == WPA_AUTH)
271 vif->auth_mode = WPA_PSK_AUTH;
272 else if (vif->auth_mode == WPA2_AUTH)
273 vif->auth_mode = WPA2_PSK_AUTH;
274 } else if (key_mgmt == 0x00409600) {
275 if (vif->auth_mode == WPA_AUTH)
276 vif->auth_mode = WPA_AUTH_CCKM;
277 else if (vif->auth_mode == WPA2_AUTH)
278 vif->auth_mode = WPA2_AUTH_CCKM;
279 } else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
280 vif->auth_mode = NONE_AUTH;
284 static bool ath6kl_cfg80211_ready(struct ath6kl_vif *vif)
286 struct ath6kl *ar = vif->ar;
288 if (!test_bit(WMI_READY, &ar->flag)) {
289 ath6kl_err("wmi is not ready\n");
293 if (!test_bit(WLAN_ENABLED, &vif->flags)) {
294 ath6kl_err("wlan disabled\n");
301 static bool ath6kl_is_wpa_ie(const u8 *pos)
303 return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
304 pos[2] == 0x00 && pos[3] == 0x50 &&
305 pos[4] == 0xf2 && pos[5] == 0x01;
308 static bool ath6kl_is_rsn_ie(const u8 *pos)
310 return pos[0] == WLAN_EID_RSN;
313 static bool ath6kl_is_wps_ie(const u8 *pos)
315 return (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
317 pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2 &&
321 static int ath6kl_set_assoc_req_ies(struct ath6kl_vif *vif, const u8 *ies,
324 struct ath6kl *ar = vif->ar;
331 * Clear previously set flag
334 ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
337 * Filter out RSN/WPA IE(s)
340 if (ies && ies_len) {
341 buf = kmalloc(ies_len, GFP_KERNEL);
346 while (pos + 1 < ies + ies_len) {
347 if (pos + 2 + pos[1] > ies + ies_len)
349 if (!(ath6kl_is_wpa_ie(pos) || ath6kl_is_rsn_ie(pos))) {
350 memcpy(buf + len, pos, 2 + pos[1]);
354 if (ath6kl_is_wps_ie(pos))
355 ar->connect_ctrl_flags |= CONNECT_WPS_FLAG;
361 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
362 WMI_FRAME_ASSOC_REQ, buf, len);
367 static int ath6kl_nliftype_to_drv_iftype(enum nl80211_iftype type, u8 *nw_type)
370 case NL80211_IFTYPE_STATION:
371 case NL80211_IFTYPE_P2P_CLIENT:
372 *nw_type = INFRA_NETWORK;
374 case NL80211_IFTYPE_ADHOC:
375 *nw_type = ADHOC_NETWORK;
377 case NL80211_IFTYPE_AP:
378 case NL80211_IFTYPE_P2P_GO:
379 *nw_type = AP_NETWORK;
382 ath6kl_err("invalid interface type %u\n", type);
389 static bool ath6kl_is_valid_iftype(struct ath6kl *ar, enum nl80211_iftype type,
390 u8 *if_idx, u8 *nw_type)
394 if (ath6kl_nliftype_to_drv_iftype(type, nw_type))
397 if (ar->ibss_if_active || ((type == NL80211_IFTYPE_ADHOC) &&
401 if (type == NL80211_IFTYPE_STATION ||
402 type == NL80211_IFTYPE_AP || type == NL80211_IFTYPE_ADHOC) {
403 for (i = 0; i < ar->vif_max; i++) {
404 if ((ar->avail_idx_map) & BIT(i)) {
411 if (type == NL80211_IFTYPE_P2P_CLIENT ||
412 type == NL80211_IFTYPE_P2P_GO) {
413 for (i = ar->max_norm_iface; i < ar->vif_max; i++) {
414 if ((ar->avail_idx_map) & BIT(i)) {
424 static bool ath6kl_is_tx_pending(struct ath6kl *ar)
426 return ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0;
429 static void ath6kl_cfg80211_sta_bmiss_enhance(struct ath6kl_vif *vif,
434 if (WARN_ON(!test_bit(WMI_READY, &vif->ar->flag)))
437 if (vif->nw_type != INFRA_NETWORK)
440 if (!test_bit(ATH6KL_FW_CAPABILITY_BMISS_ENHANCE,
441 vif->ar->fw_capabilities))
444 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s fw bmiss enhance\n",
445 enable ? "enable" : "disable");
447 err = ath6kl_wmi_sta_bmiss_enhance_cmd(vif->ar->wmi,
448 vif->fw_vif_idx, enable);
450 ath6kl_err("failed to %s enhanced bmiss detection: %d\n",
451 enable ? "enable" : "disable", err);
454 static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
455 struct cfg80211_connect_params *sme)
457 struct ath6kl *ar = ath6kl_priv(dev);
458 struct ath6kl_vif *vif = netdev_priv(dev);
460 u8 nw_subtype = (ar->p2p) ? SUBTYPE_P2PDEV : SUBTYPE_NONE;
463 ath6kl_cfg80211_sscan_disable(vif);
465 vif->sme_state = SME_CONNECTING;
467 if (!ath6kl_cfg80211_ready(vif))
470 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
471 ath6kl_err("destroy in progress\n");
475 if (test_bit(SKIP_SCAN, &ar->flag) &&
476 ((sme->channel && sme->channel->center_freq == 0) ||
477 (sme->bssid && is_zero_ether_addr(sme->bssid)))) {
478 ath6kl_err("SkipScan: channel or bssid invalid\n");
482 if (down_interruptible(&ar->sem)) {
483 ath6kl_err("busy, couldn't get access\n");
487 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
488 ath6kl_err("busy, destroy in progress\n");
493 if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) {
495 * sleep until the command queue drains
497 wait_event_interruptible_timeout(ar->event_wq,
498 ath6kl_is_tx_pending(ar),
500 if (signal_pending(current)) {
501 ath6kl_err("cmd queue drain timeout\n");
507 status = ath6kl_set_assoc_req_ies(vif, sme->ie, sme->ie_len);
513 if (sme->ie == NULL || sme->ie_len == 0)
514 ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
516 if (test_bit(CONNECTED, &vif->flags) &&
517 vif->ssid_len == sme->ssid_len &&
518 !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
519 vif->reconnect_flag = true;
520 status = ath6kl_wmi_reconnect_cmd(ar->wmi, vif->fw_vif_idx,
526 ath6kl_err("wmi_reconnect_cmd failed\n");
530 } else if (vif->ssid_len == sme->ssid_len &&
531 !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
532 ath6kl_disconnect(vif);
535 memset(vif->ssid, 0, sizeof(vif->ssid));
536 vif->ssid_len = sme->ssid_len;
537 memcpy(vif->ssid, sme->ssid, sme->ssid_len);
540 vif->ch_hint = sme->channel->center_freq;
542 memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
543 if (sme->bssid && !is_broadcast_ether_addr(sme->bssid))
544 memcpy(vif->req_bssid, sme->bssid, sizeof(vif->req_bssid));
546 ath6kl_set_wpa_version(vif, sme->crypto.wpa_versions);
548 status = ath6kl_set_auth_type(vif, sme->auth_type);
554 if (sme->crypto.n_ciphers_pairwise)
555 ath6kl_set_cipher(vif, sme->crypto.ciphers_pairwise[0], true);
557 ath6kl_set_cipher(vif, 0, true);
559 ath6kl_set_cipher(vif, sme->crypto.cipher_group, false);
561 if (sme->crypto.n_akm_suites)
562 ath6kl_set_key_mgmt(vif, sme->crypto.akm_suites[0]);
564 if ((sme->key_len) &&
565 (vif->auth_mode == NONE_AUTH) &&
566 (vif->prwise_crypto == WEP_CRYPT)) {
567 struct ath6kl_key *key = NULL;
569 if (sme->key_idx > WMI_MAX_KEY_INDEX) {
570 ath6kl_err("key index %d out of bounds\n",
576 key = &vif->keys[sme->key_idx];
577 key->key_len = sme->key_len;
578 memcpy(key->key, sme->key, key->key_len);
579 key->cipher = vif->prwise_crypto;
580 vif->def_txkey_index = sme->key_idx;
582 ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, sme->key_idx,
584 GROUP_USAGE | TX_USAGE,
587 key->key, KEY_OP_INIT_VAL, NULL,
591 if (!ar->usr_bss_filter) {
592 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
593 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
594 ALL_BSS_FILTER, 0) != 0) {
595 ath6kl_err("couldn't set bss filtering\n");
601 vif->nw_type = vif->next_mode;
603 /* enable enhanced bmiss detection if applicable */
604 ath6kl_cfg80211_sta_bmiss_enhance(vif, true);
606 if (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT)
607 nw_subtype = SUBTYPE_P2PCLIENT;
609 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
610 "%s: connect called with authmode %d dot11 auth %d"
611 " PW crypto %d PW crypto len %d GRP crypto %d"
612 " GRP crypto len %d channel hint %u\n",
614 vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
615 vif->prwise_crypto_len, vif->grp_crypto,
616 vif->grp_crypto_len, vif->ch_hint);
618 vif->reconnect_flag = 0;
620 if (vif->nw_type == INFRA_NETWORK) {
621 interval = max_t(u16, vif->listen_intvl_t,
622 ATH6KL_MAX_WOW_LISTEN_INTL);
623 status = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
627 ath6kl_err("couldn't set listen intervel\n");
633 status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
634 vif->dot11_auth_mode, vif->auth_mode,
636 vif->prwise_crypto_len,
637 vif->grp_crypto, vif->grp_crypto_len,
638 vif->ssid_len, vif->ssid,
639 vif->req_bssid, vif->ch_hint,
640 ar->connect_ctrl_flags, nw_subtype);
642 if (sme->bg_scan_period == 0) {
643 /* disable background scan if period is 0 */
644 sme->bg_scan_period = 0xffff;
645 } else if (sme->bg_scan_period == -1) {
646 /* configure default value if not specified */
647 sme->bg_scan_period = DEFAULT_BG_SCAN_PERIOD;
650 ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx, 0, 0,
651 sme->bg_scan_period, 0, 0, 0, 3, 0, 0, 0);
655 if (status == -EINVAL) {
656 memset(vif->ssid, 0, sizeof(vif->ssid));
658 ath6kl_err("invalid request\n");
661 ath6kl_err("ath6kl_wmi_connect_cmd failed\n");
665 if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) &&
666 ((vif->auth_mode == WPA_PSK_AUTH) ||
667 (vif->auth_mode == WPA2_PSK_AUTH))) {
668 mod_timer(&vif->disconnect_timer,
669 jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL));
672 ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD;
673 set_bit(CONNECT_PEND, &vif->flags);
678 static struct cfg80211_bss *
679 ath6kl_add_bss_if_needed(struct ath6kl_vif *vif,
680 enum network_type nw_type,
682 struct ieee80211_channel *chan,
684 size_t beacon_ie_len)
686 struct ath6kl *ar = vif->ar;
687 struct cfg80211_bss *bss;
689 enum ieee80211_bss_type bss_type;
692 if (nw_type & ADHOC_NETWORK) {
693 cap_val = WLAN_CAPABILITY_IBSS;
694 bss_type = IEEE80211_BSS_TYPE_IBSS;
696 cap_val = WLAN_CAPABILITY_ESS;
697 bss_type = IEEE80211_BSS_TYPE_ESS;
700 bss = cfg80211_get_bss(ar->wiphy, chan, bssid,
701 vif->ssid, vif->ssid_len,
702 bss_type, IEEE80211_PRIVACY_ANY);
705 * Since cfg80211 may not yet know about the BSS,
706 * generate a partial entry until the first BSS info
707 * event becomes available.
709 * Prepend SSID element since it is not included in the Beacon
710 * IEs from the target.
712 ie = kmalloc(2 + vif->ssid_len + beacon_ie_len, GFP_KERNEL);
715 ie[0] = WLAN_EID_SSID;
716 ie[1] = vif->ssid_len;
717 memcpy(ie + 2, vif->ssid, vif->ssid_len);
718 memcpy(ie + 2 + vif->ssid_len, beacon_ie, beacon_ie_len);
719 bss = cfg80211_inform_bss(ar->wiphy, chan,
720 CFG80211_BSS_FTYPE_UNKNOWN,
721 bssid, 0, cap_val, 100,
722 ie, 2 + vif->ssid_len + beacon_ie_len,
725 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
726 "added bss %pM to cfg80211\n", bssid);
729 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "cfg80211 already has a bss\n");
735 void ath6kl_cfg80211_connect_event(struct ath6kl_vif *vif, u16 channel,
736 u8 *bssid, u16 listen_intvl,
738 enum network_type nw_type,
739 u8 beacon_ie_len, u8 assoc_req_len,
740 u8 assoc_resp_len, u8 *assoc_info)
742 struct ieee80211_channel *chan;
743 struct ath6kl *ar = vif->ar;
744 struct cfg80211_bss *bss;
746 /* capinfo + listen interval */
747 u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16);
749 /* capinfo + status code + associd */
750 u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16);
752 u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset;
753 u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len +
754 assoc_resp_ie_offset;
756 assoc_req_len -= assoc_req_ie_offset;
757 assoc_resp_len -= assoc_resp_ie_offset;
760 * Store Beacon interval here; DTIM period will be available only once
761 * a Beacon frame from the AP is seen.
763 vif->assoc_bss_beacon_int = beacon_intvl;
764 clear_bit(DTIM_PERIOD_AVAIL, &vif->flags);
766 if (nw_type & ADHOC_NETWORK) {
767 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) {
768 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
769 "%s: ath6k not in ibss mode\n", __func__);
774 if (nw_type & INFRA_NETWORK) {
775 if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
776 vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
777 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
778 "%s: ath6k not in station mode\n", __func__);
783 chan = ieee80211_get_channel(ar->wiphy, (int) channel);
785 bss = ath6kl_add_bss_if_needed(vif, nw_type, bssid, chan,
786 assoc_info, beacon_ie_len);
788 ath6kl_err("could not add cfg80211 bss entry\n");
792 if (nw_type & ADHOC_NETWORK) {
793 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "ad-hoc %s selected\n",
794 nw_type & ADHOC_CREATOR ? "creator" : "joiner");
795 cfg80211_ibss_joined(vif->ndev, bssid, chan, GFP_KERNEL);
796 cfg80211_put_bss(ar->wiphy, bss);
800 if (vif->sme_state == SME_CONNECTING) {
801 /* inform connect result to cfg80211 */
802 vif->sme_state = SME_CONNECTED;
803 cfg80211_connect_result(vif->ndev, bssid,
804 assoc_req_ie, assoc_req_len,
805 assoc_resp_ie, assoc_resp_len,
806 WLAN_STATUS_SUCCESS, GFP_KERNEL);
807 cfg80211_put_bss(ar->wiphy, bss);
808 } else if (vif->sme_state == SME_CONNECTED) {
809 /* inform roam event to cfg80211 */
810 cfg80211_roamed_bss(vif->ndev, bss, assoc_req_ie, assoc_req_len,
811 assoc_resp_ie, assoc_resp_len, GFP_KERNEL);
815 static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy,
816 struct net_device *dev, u16 reason_code)
818 struct ath6kl *ar = ath6kl_priv(dev);
819 struct ath6kl_vif *vif = netdev_priv(dev);
821 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__,
824 ath6kl_cfg80211_sscan_disable(vif);
826 if (!ath6kl_cfg80211_ready(vif))
829 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
830 ath6kl_err("busy, destroy in progress\n");
834 if (down_interruptible(&ar->sem)) {
835 ath6kl_err("busy, couldn't get access\n");
839 vif->reconnect_flag = 0;
840 ath6kl_disconnect(vif);
841 memset(vif->ssid, 0, sizeof(vif->ssid));
844 if (!test_bit(SKIP_SCAN, &ar->flag))
845 memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
852 void ath6kl_cfg80211_disconnect_event(struct ath6kl_vif *vif, u8 reason,
853 u8 *bssid, u8 assoc_resp_len,
854 u8 *assoc_info, u16 proto_reason)
856 struct ath6kl *ar = vif->ar;
859 struct cfg80211_scan_info info = {
863 cfg80211_scan_done(vif->scan_req, &info);
864 vif->scan_req = NULL;
867 if (vif->nw_type & ADHOC_NETWORK) {
868 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC)
869 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
870 "%s: ath6k not in ibss mode\n", __func__);
874 if (vif->nw_type & INFRA_NETWORK) {
875 if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
876 vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
877 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
878 "%s: ath6k not in station mode\n", __func__);
883 clear_bit(CONNECT_PEND, &vif->flags);
885 if (vif->sme_state == SME_CONNECTING) {
886 cfg80211_connect_result(vif->ndev,
889 WLAN_STATUS_UNSPECIFIED_FAILURE,
891 } else if (vif->sme_state == SME_CONNECTED) {
892 cfg80211_disconnected(vif->ndev, proto_reason,
893 NULL, 0, false, GFP_KERNEL);
896 vif->sme_state = SME_DISCONNECTED;
899 * Send a disconnect command to target when a disconnect event is
900 * received with reason code other than 3 (DISCONNECT_CMD - disconnect
901 * request from host) to make the firmware stop trying to connect even
902 * after giving disconnect event. There will be one more disconnect
903 * event for this disconnect command with reason code DISCONNECT_CMD
904 * which won't be notified to cfg80211.
906 if (reason != DISCONNECT_CMD)
907 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
910 static int ath6kl_set_probed_ssids(struct ath6kl *ar,
911 struct ath6kl_vif *vif,
912 struct cfg80211_ssid *ssids, int n_ssids,
913 struct cfg80211_match_set *match_set,
916 u8 i, j, index_to_add, ssid_found = false;
917 struct ath6kl_cfg80211_match_probe_ssid ssid_list[MAX_PROBED_SSIDS];
919 memset(ssid_list, 0, sizeof(ssid_list));
921 if (n_ssids > MAX_PROBED_SSIDS ||
922 n_match_ssid > MAX_PROBED_SSIDS)
925 for (i = 0; i < n_ssids; i++) {
926 memcpy(ssid_list[i].ssid.ssid,
929 ssid_list[i].ssid.ssid_len = ssids[i].ssid_len;
931 if (ssids[i].ssid_len)
932 ssid_list[i].flag = SPECIFIC_SSID_FLAG;
934 ssid_list[i].flag = ANY_SSID_FLAG;
936 if (n_match_ssid == 0)
937 ssid_list[i].flag |= MATCH_SSID_FLAG;
942 for (i = 0; i < n_match_ssid; i++) {
945 for (j = 0; j < n_ssids; j++) {
946 if ((match_set[i].ssid.ssid_len ==
947 ssid_list[j].ssid.ssid_len) &&
948 (!memcmp(ssid_list[j].ssid.ssid,
949 match_set[i].ssid.ssid,
950 match_set[i].ssid.ssid_len))) {
951 ssid_list[j].flag |= MATCH_SSID_FLAG;
960 if (index_to_add >= MAX_PROBED_SSIDS)
963 ssid_list[index_to_add].ssid.ssid_len =
964 match_set[i].ssid.ssid_len;
965 memcpy(ssid_list[index_to_add].ssid.ssid,
966 match_set[i].ssid.ssid,
967 match_set[i].ssid.ssid_len);
968 ssid_list[index_to_add].flag |= MATCH_SSID_FLAG;
972 for (i = 0; i < index_to_add; i++) {
973 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, i,
975 ssid_list[i].ssid.ssid_len,
976 ssid_list[i].ssid.ssid);
979 /* Make sure no old entries are left behind */
980 for (i = index_to_add; i < MAX_PROBED_SSIDS; i++) {
981 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, i,
982 DISABLE_SSID_FLAG, 0, NULL);
988 static int ath6kl_cfg80211_scan(struct wiphy *wiphy,
989 struct cfg80211_scan_request *request)
991 struct ath6kl_vif *vif = ath6kl_vif_from_wdev(request->wdev);
992 struct ath6kl *ar = ath6kl_priv(vif->ndev);
994 u16 *channels = NULL;
996 u32 force_fg_scan = 0;
998 if (!ath6kl_cfg80211_ready(vif))
1001 ath6kl_cfg80211_sscan_disable(vif);
1003 if (!ar->usr_bss_filter) {
1004 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
1005 ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
1008 ath6kl_err("couldn't set bss filtering\n");
1013 ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
1014 request->n_ssids, NULL, 0);
1018 /* this also clears IE in fw if it's not set */
1019 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
1020 WMI_FRAME_PROBE_REQ,
1021 request->ie, request->ie_len);
1023 ath6kl_err("failed to set Probe Request appie for scan\n");
1028 * Scan only the requested channels if the request specifies a set of
1029 * channels. If the list is longer than the target supports, do not
1030 * configure the list and instead, scan all available channels.
1032 if (request->n_channels > 0 &&
1033 request->n_channels <= WMI_MAX_CHANNELS) {
1036 n_channels = request->n_channels;
1038 channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL);
1039 if (channels == NULL) {
1040 ath6kl_warn("failed to set scan channels, scan all channels");
1044 for (i = 0; i < n_channels; i++)
1045 channels[i] = request->channels[i]->center_freq;
1048 if (test_bit(CONNECTED, &vif->flags))
1051 vif->scan_req = request;
1053 ret = ath6kl_wmi_beginscan_cmd(ar->wmi, vif->fw_vif_idx,
1054 WMI_LONG_SCAN, force_fg_scan,
1056 ATH6KL_FG_SCAN_INTERVAL,
1057 n_channels, channels,
1061 ath6kl_err("failed to start scan: %d\n", ret);
1062 vif->scan_req = NULL;
1070 void ath6kl_cfg80211_scan_complete_event(struct ath6kl_vif *vif, bool aborted)
1072 struct ath6kl *ar = vif->ar;
1073 struct cfg80211_scan_info info = {
1078 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status%s\n", __func__,
1079 aborted ? " aborted" : "");
1087 if (vif->scan_req->n_ssids && vif->scan_req->ssids[0].ssid_len) {
1088 for (i = 0; i < vif->scan_req->n_ssids; i++) {
1089 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx,
1090 i + 1, DISABLE_SSID_FLAG,
1096 cfg80211_scan_done(vif->scan_req, &info);
1097 vif->scan_req = NULL;
1100 void ath6kl_cfg80211_ch_switch_notify(struct ath6kl_vif *vif, int freq,
1101 enum wmi_phy_mode mode)
1103 struct cfg80211_chan_def chandef;
1105 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1106 "channel switch notify nw_type %d freq %d mode %d\n",
1107 vif->nw_type, freq, mode);
1109 cfg80211_chandef_create(&chandef,
1110 ieee80211_get_channel(vif->ar->wiphy, freq),
1111 (mode == WMI_11G_HT20 &&
1112 ath6kl_band_2ghz.ht_cap.ht_supported) ?
1113 NL80211_CHAN_HT20 : NL80211_CHAN_NO_HT);
1115 mutex_lock(&vif->wdev.mtx);
1116 cfg80211_ch_switch_notify(vif->ndev, &chandef);
1117 mutex_unlock(&vif->wdev.mtx);
1120 static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
1121 u8 key_index, bool pairwise,
1123 struct key_params *params)
1125 struct ath6kl *ar = ath6kl_priv(ndev);
1126 struct ath6kl_vif *vif = netdev_priv(ndev);
1127 struct ath6kl_key *key = NULL;
1132 if (!ath6kl_cfg80211_ready(vif))
1135 if (params->cipher == CCKM_KRK_CIPHER_SUITE) {
1136 if (params->key_len != WMI_KRK_LEN)
1138 return ath6kl_wmi_add_krk_cmd(ar->wmi, vif->fw_vif_idx,
1142 if (key_index > WMI_MAX_KEY_INDEX) {
1143 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1144 "%s: key index %d out of bounds\n", __func__,
1149 key = &vif->keys[key_index];
1150 memset(key, 0, sizeof(struct ath6kl_key));
1153 key_usage = PAIRWISE_USAGE;
1155 key_usage = GROUP_USAGE;
1157 seq_len = params->seq_len;
1158 if (params->cipher == WLAN_CIPHER_SUITE_SMS4 &&
1159 seq_len > ATH6KL_KEY_SEQ_LEN) {
1160 /* Only first half of the WPI PN is configured */
1161 seq_len = ATH6KL_KEY_SEQ_LEN;
1163 if (params->key_len > WLAN_MAX_KEY_LEN ||
1164 seq_len > sizeof(key->seq))
1167 key->key_len = params->key_len;
1168 memcpy(key->key, params->key, key->key_len);
1169 key->seq_len = seq_len;
1170 memcpy(key->seq, params->seq, key->seq_len);
1171 key->cipher = params->cipher;
1173 switch (key->cipher) {
1174 case WLAN_CIPHER_SUITE_WEP40:
1175 case WLAN_CIPHER_SUITE_WEP104:
1176 key_type = WEP_CRYPT;
1179 case WLAN_CIPHER_SUITE_TKIP:
1180 key_type = TKIP_CRYPT;
1183 case WLAN_CIPHER_SUITE_CCMP:
1184 key_type = AES_CRYPT;
1186 case WLAN_CIPHER_SUITE_SMS4:
1187 key_type = WAPI_CRYPT;
1194 if (((vif->auth_mode == WPA_PSK_AUTH) ||
1195 (vif->auth_mode == WPA2_PSK_AUTH)) &&
1196 (key_usage & GROUP_USAGE))
1197 del_timer(&vif->disconnect_timer);
1199 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1200 "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n",
1201 __func__, key_index, key->key_len, key_type,
1202 key_usage, key->seq_len);
1204 if (vif->nw_type == AP_NETWORK && !pairwise &&
1205 (key_type == TKIP_CRYPT || key_type == AES_CRYPT ||
1206 key_type == WAPI_CRYPT)) {
1207 ar->ap_mode_bkey.valid = true;
1208 ar->ap_mode_bkey.key_index = key_index;
1209 ar->ap_mode_bkey.key_type = key_type;
1210 ar->ap_mode_bkey.key_len = key->key_len;
1211 memcpy(ar->ap_mode_bkey.key, key->key, key->key_len);
1212 if (!test_bit(CONNECTED, &vif->flags)) {
1213 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1214 "Delay initial group key configuration until AP mode has been started\n");
1216 * The key will be set in ath6kl_connect_ap_mode() once
1217 * the connected event is received from the target.
1223 if (vif->next_mode == AP_NETWORK && key_type == WEP_CRYPT &&
1224 !test_bit(CONNECTED, &vif->flags)) {
1226 * Store the key locally so that it can be re-configured after
1227 * the AP mode has properly started
1228 * (ath6kl_install_statioc_wep_keys).
1230 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1231 "Delay WEP key configuration until AP mode has been started\n");
1232 vif->wep_key_list[key_index].key_len = key->key_len;
1233 memcpy(vif->wep_key_list[key_index].key, key->key,
1238 return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, key_index,
1239 key_type, key_usage, key->key_len,
1240 key->seq, key->seq_len, key->key,
1242 (u8 *) mac_addr, SYNC_BOTH_WMIFLAG);
1245 static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
1246 u8 key_index, bool pairwise,
1249 struct ath6kl *ar = ath6kl_priv(ndev);
1250 struct ath6kl_vif *vif = netdev_priv(ndev);
1252 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1254 if (!ath6kl_cfg80211_ready(vif))
1257 if (key_index > WMI_MAX_KEY_INDEX) {
1258 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1259 "%s: key index %d out of bounds\n", __func__,
1264 if (!vif->keys[key_index].key_len) {
1265 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1266 "%s: index %d is empty\n", __func__, key_index);
1270 vif->keys[key_index].key_len = 0;
1272 return ath6kl_wmi_deletekey_cmd(ar->wmi, vif->fw_vif_idx, key_index);
1275 static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
1276 u8 key_index, bool pairwise,
1277 const u8 *mac_addr, void *cookie,
1278 void (*callback) (void *cookie,
1279 struct key_params *))
1281 struct ath6kl_vif *vif = netdev_priv(ndev);
1282 struct ath6kl_key *key = NULL;
1283 struct key_params params;
1285 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1287 if (!ath6kl_cfg80211_ready(vif))
1290 if (key_index > WMI_MAX_KEY_INDEX) {
1291 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1292 "%s: key index %d out of bounds\n", __func__,
1297 key = &vif->keys[key_index];
1298 memset(¶ms, 0, sizeof(params));
1299 params.cipher = key->cipher;
1300 params.key_len = key->key_len;
1301 params.seq_len = key->seq_len;
1302 params.seq = key->seq;
1303 params.key = key->key;
1305 callback(cookie, ¶ms);
1307 return key->key_len ? 0 : -ENOENT;
1310 static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy,
1311 struct net_device *ndev,
1312 u8 key_index, bool unicast,
1315 struct ath6kl *ar = ath6kl_priv(ndev);
1316 struct ath6kl_vif *vif = netdev_priv(ndev);
1317 struct ath6kl_key *key = NULL;
1319 enum crypto_type key_type = NONE_CRYPT;
1321 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1323 if (!ath6kl_cfg80211_ready(vif))
1326 if (key_index > WMI_MAX_KEY_INDEX) {
1327 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1328 "%s: key index %d out of bounds\n",
1329 __func__, key_index);
1333 if (!vif->keys[key_index].key_len) {
1334 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n",
1335 __func__, key_index);
1339 vif->def_txkey_index = key_index;
1340 key = &vif->keys[vif->def_txkey_index];
1341 key_usage = GROUP_USAGE;
1342 if (vif->prwise_crypto == WEP_CRYPT)
1343 key_usage |= TX_USAGE;
1345 key_type = vif->prwise_crypto;
1347 key_type = vif->grp_crypto;
1349 if (vif->next_mode == AP_NETWORK && !test_bit(CONNECTED, &vif->flags))
1350 return 0; /* Delay until AP mode has been started */
1352 return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx,
1353 vif->def_txkey_index,
1354 key_type, key_usage,
1355 key->key_len, key->seq, key->seq_len,
1357 KEY_OP_INIT_VAL, NULL,
1361 void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl_vif *vif, u8 keyid,
1364 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1365 "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast);
1367 cfg80211_michael_mic_failure(vif->ndev, vif->bssid,
1368 (ismcast ? NL80211_KEYTYPE_GROUP :
1369 NL80211_KEYTYPE_PAIRWISE), keyid, NULL,
1373 static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1375 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1376 struct ath6kl_vif *vif;
1379 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__,
1382 vif = ath6kl_vif_first(ar);
1386 if (!ath6kl_cfg80211_ready(vif))
1389 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1390 ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold);
1392 ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n");
1400 static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy,
1401 struct wireless_dev *wdev,
1402 enum nl80211_tx_power_setting type,
1405 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1406 struct ath6kl_vif *vif;
1407 int dbm = MBM_TO_DBM(mbm);
1409 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__,
1412 vif = ath6kl_vif_first(ar);
1416 if (!ath6kl_cfg80211_ready(vif))
1420 case NL80211_TX_POWER_AUTOMATIC:
1422 case NL80211_TX_POWER_LIMITED:
1426 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n",
1431 ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx, dbm);
1436 static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy,
1437 struct wireless_dev *wdev,
1440 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1441 struct ath6kl_vif *vif;
1443 vif = ath6kl_vif_first(ar);
1447 if (!ath6kl_cfg80211_ready(vif))
1450 if (test_bit(CONNECTED, &vif->flags)) {
1453 if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx) != 0) {
1454 ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n");
1458 wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 255,
1461 if (signal_pending(current)) {
1462 ath6kl_err("target did not respond\n");
1471 static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
1472 struct net_device *dev,
1473 bool pmgmt, int timeout)
1475 struct ath6kl *ar = ath6kl_priv(dev);
1476 struct wmi_power_mode_cmd mode;
1477 struct ath6kl_vif *vif = netdev_priv(dev);
1479 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n",
1480 __func__, pmgmt, timeout);
1482 if (!ath6kl_cfg80211_ready(vif))
1486 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__);
1487 mode.pwr_mode = REC_POWER;
1489 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__);
1490 mode.pwr_mode = MAX_PERF_POWER;
1493 if (ath6kl_wmi_powermode_cmd(ar->wmi, vif->fw_vif_idx,
1494 mode.pwr_mode) != 0) {
1495 ath6kl_err("wmi_powermode_cmd failed\n");
1502 static struct wireless_dev *ath6kl_cfg80211_add_iface(struct wiphy *wiphy,
1504 unsigned char name_assign_type,
1505 enum nl80211_iftype type,
1507 struct vif_params *params)
1509 struct ath6kl *ar = wiphy_priv(wiphy);
1510 struct wireless_dev *wdev;
1513 if (ar->num_vif == ar->vif_max) {
1514 ath6kl_err("Reached maximum number of supported vif\n");
1515 return ERR_PTR(-EINVAL);
1518 if (!ath6kl_is_valid_iftype(ar, type, &if_idx, &nw_type)) {
1519 ath6kl_err("Not a supported interface type\n");
1520 return ERR_PTR(-EINVAL);
1523 wdev = ath6kl_interface_add(ar, name, name_assign_type, type, if_idx, nw_type);
1525 return ERR_PTR(-ENOMEM);
1532 static int ath6kl_cfg80211_del_iface(struct wiphy *wiphy,
1533 struct wireless_dev *wdev)
1535 struct ath6kl *ar = wiphy_priv(wiphy);
1536 struct ath6kl_vif *vif = netdev_priv(wdev->netdev);
1538 spin_lock_bh(&ar->list_lock);
1539 list_del(&vif->list);
1540 spin_unlock_bh(&ar->list_lock);
1542 ath6kl_cfg80211_vif_stop(vif, test_bit(WMI_READY, &ar->flag));
1545 ath6kl_cfg80211_vif_cleanup(vif);
1551 static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy,
1552 struct net_device *ndev,
1553 enum nl80211_iftype type, u32 *flags,
1554 struct vif_params *params)
1556 struct ath6kl_vif *vif = netdev_priv(ndev);
1559 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type);
1562 * Don't bring up p2p on an interface which is not initialized
1563 * for p2p operation where fw does not have capability to switch
1564 * dynamically between non-p2p and p2p type interface.
1566 if (!test_bit(ATH6KL_FW_CAPABILITY_STA_P2PDEV_DUPLEX,
1567 vif->ar->fw_capabilities) &&
1568 (type == NL80211_IFTYPE_P2P_CLIENT ||
1569 type == NL80211_IFTYPE_P2P_GO)) {
1570 if (vif->ar->vif_max == 1) {
1571 if (vif->fw_vif_idx != 0)
1574 goto set_iface_type;
1577 for (i = vif->ar->max_norm_iface; i < vif->ar->vif_max; i++) {
1578 if (i == vif->fw_vif_idx)
1582 if (i == vif->ar->vif_max) {
1583 ath6kl_err("Invalid interface to bring up P2P\n");
1588 /* need to clean up enhanced bmiss detection fw state */
1589 ath6kl_cfg80211_sta_bmiss_enhance(vif, false);
1593 case NL80211_IFTYPE_STATION:
1594 case NL80211_IFTYPE_P2P_CLIENT:
1595 vif->next_mode = INFRA_NETWORK;
1597 case NL80211_IFTYPE_ADHOC:
1598 vif->next_mode = ADHOC_NETWORK;
1600 case NL80211_IFTYPE_AP:
1601 case NL80211_IFTYPE_P2P_GO:
1602 vif->next_mode = AP_NETWORK;
1605 ath6kl_err("invalid interface type %u\n", type);
1609 vif->wdev.iftype = type;
1614 static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy,
1615 struct net_device *dev,
1616 struct cfg80211_ibss_params *ibss_param)
1618 struct ath6kl *ar = ath6kl_priv(dev);
1619 struct ath6kl_vif *vif = netdev_priv(dev);
1622 if (!ath6kl_cfg80211_ready(vif))
1625 vif->ssid_len = ibss_param->ssid_len;
1626 memcpy(vif->ssid, ibss_param->ssid, vif->ssid_len);
1628 if (ibss_param->chandef.chan)
1629 vif->ch_hint = ibss_param->chandef.chan->center_freq;
1631 if (ibss_param->channel_fixed) {
1633 * TODO: channel_fixed: The channel should be fixed, do not
1634 * search for IBSSs to join on other channels. Target
1635 * firmware does not support this feature, needs to be
1641 memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
1642 if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid))
1643 memcpy(vif->req_bssid, ibss_param->bssid,
1644 sizeof(vif->req_bssid));
1646 ath6kl_set_wpa_version(vif, 0);
1648 status = ath6kl_set_auth_type(vif, NL80211_AUTHTYPE_OPEN_SYSTEM);
1652 if (ibss_param->privacy) {
1653 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, true);
1654 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, false);
1656 ath6kl_set_cipher(vif, 0, true);
1657 ath6kl_set_cipher(vif, 0, false);
1660 vif->nw_type = vif->next_mode;
1662 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1663 "%s: connect called with authmode %d dot11 auth %d"
1664 " PW crypto %d PW crypto len %d GRP crypto %d"
1665 " GRP crypto len %d channel hint %u\n",
1667 vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
1668 vif->prwise_crypto_len, vif->grp_crypto,
1669 vif->grp_crypto_len, vif->ch_hint);
1671 status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
1672 vif->dot11_auth_mode, vif->auth_mode,
1674 vif->prwise_crypto_len,
1675 vif->grp_crypto, vif->grp_crypto_len,
1676 vif->ssid_len, vif->ssid,
1677 vif->req_bssid, vif->ch_hint,
1678 ar->connect_ctrl_flags, SUBTYPE_NONE);
1679 set_bit(CONNECT_PEND, &vif->flags);
1684 static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy,
1685 struct net_device *dev)
1687 struct ath6kl_vif *vif = netdev_priv(dev);
1689 if (!ath6kl_cfg80211_ready(vif))
1692 ath6kl_disconnect(vif);
1693 memset(vif->ssid, 0, sizeof(vif->ssid));
1699 static const u32 cipher_suites[] = {
1700 WLAN_CIPHER_SUITE_WEP40,
1701 WLAN_CIPHER_SUITE_WEP104,
1702 WLAN_CIPHER_SUITE_TKIP,
1703 WLAN_CIPHER_SUITE_CCMP,
1704 CCKM_KRK_CIPHER_SUITE,
1705 WLAN_CIPHER_SUITE_SMS4,
1708 static bool is_rate_legacy(s32 rate)
1710 static const s32 legacy[] = { 1000, 2000, 5500, 11000,
1711 6000, 9000, 12000, 18000, 24000,
1716 for (i = 0; i < ARRAY_SIZE(legacy); i++)
1717 if (rate == legacy[i])
1723 static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
1725 static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
1726 52000, 58500, 65000, 72200
1730 for (i = 0; i < ARRAY_SIZE(ht20); i++) {
1731 if (rate == ht20[i]) {
1732 if (i == ARRAY_SIZE(ht20) - 1)
1733 /* last rate uses sgi */
1745 static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
1747 static const s32 ht40[] = { 13500, 27000, 40500, 54000,
1748 81000, 108000, 121500, 135000,
1753 for (i = 0; i < ARRAY_SIZE(ht40); i++) {
1754 if (rate == ht40[i]) {
1755 if (i == ARRAY_SIZE(ht40) - 1)
1756 /* last rate uses sgi */
1769 static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev,
1770 const u8 *mac, struct station_info *sinfo)
1772 struct ath6kl *ar = ath6kl_priv(dev);
1773 struct ath6kl_vif *vif = netdev_priv(dev);
1780 if (memcmp(mac, vif->bssid, ETH_ALEN) != 0)
1783 if (down_interruptible(&ar->sem))
1786 set_bit(STATS_UPDATE_PEND, &vif->flags);
1788 ret = ath6kl_wmi_get_stats_cmd(ar->wmi, vif->fw_vif_idx);
1795 left = wait_event_interruptible_timeout(ar->event_wq,
1796 !test_bit(STATS_UPDATE_PEND,
1807 if (vif->target_stats.rx_byte) {
1808 sinfo->rx_bytes = vif->target_stats.rx_byte;
1809 sinfo->filled |= BIT(NL80211_STA_INFO_RX_BYTES64);
1810 sinfo->rx_packets = vif->target_stats.rx_pkt;
1811 sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS);
1814 if (vif->target_stats.tx_byte) {
1815 sinfo->tx_bytes = vif->target_stats.tx_byte;
1816 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BYTES64);
1817 sinfo->tx_packets = vif->target_stats.tx_pkt;
1818 sinfo->filled |= BIT(NL80211_STA_INFO_TX_PACKETS);
1821 sinfo->signal = vif->target_stats.cs_rssi;
1822 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
1824 rate = vif->target_stats.tx_ucast_rate;
1826 if (is_rate_legacy(rate)) {
1827 sinfo->txrate.legacy = rate / 100;
1828 } else if (is_rate_ht20(rate, &mcs, &sgi)) {
1830 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1831 sinfo->txrate.mcs = mcs - 1;
1833 sinfo->txrate.mcs = mcs;
1836 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1837 sinfo->txrate.bw = RATE_INFO_BW_20;
1838 } else if (is_rate_ht40(rate, &mcs, &sgi)) {
1840 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1841 sinfo->txrate.mcs = mcs - 1;
1843 sinfo->txrate.mcs = mcs;
1846 sinfo->txrate.bw = RATE_INFO_BW_40;
1847 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1849 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1850 "invalid rate from stats: %d\n", rate);
1851 ath6kl_debug_war(ar, ATH6KL_WAR_INVALID_RATE);
1855 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
1857 if (test_bit(CONNECTED, &vif->flags) &&
1858 test_bit(DTIM_PERIOD_AVAIL, &vif->flags) &&
1859 vif->nw_type == INFRA_NETWORK) {
1860 sinfo->filled |= BIT(NL80211_STA_INFO_BSS_PARAM);
1861 sinfo->bss_param.flags = 0;
1862 sinfo->bss_param.dtim_period = vif->assoc_bss_dtim_period;
1863 sinfo->bss_param.beacon_interval = vif->assoc_bss_beacon_int;
1869 static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1870 struct cfg80211_pmksa *pmksa)
1872 struct ath6kl *ar = ath6kl_priv(netdev);
1873 struct ath6kl_vif *vif = netdev_priv(netdev);
1875 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1876 pmksa->pmkid, true);
1879 static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1880 struct cfg80211_pmksa *pmksa)
1882 struct ath6kl *ar = ath6kl_priv(netdev);
1883 struct ath6kl_vif *vif = netdev_priv(netdev);
1885 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1886 pmksa->pmkid, false);
1889 static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1891 struct ath6kl *ar = ath6kl_priv(netdev);
1892 struct ath6kl_vif *vif = netdev_priv(netdev);
1894 if (test_bit(CONNECTED, &vif->flags))
1895 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx,
1896 vif->bssid, NULL, false);
1900 static int ath6kl_wow_usr(struct ath6kl *ar, struct ath6kl_vif *vif,
1901 struct cfg80211_wowlan *wow, u32 *filter)
1904 u8 mask[WOW_PATTERN_SIZE];
1907 /* Configure the patterns that we received from the user. */
1908 for (i = 0; i < wow->n_patterns; i++) {
1910 * Convert given nl80211 specific mask value to equivalent
1911 * driver specific mask value and send it to the chip along
1912 * with patterns. For example, If the mask value defined in
1913 * struct cfg80211_wowlan is 0xA (equivalent binary is 1010),
1914 * then equivalent driver specific mask value is
1915 * "0xFF 0x00 0xFF 0x00".
1917 memset(&mask, 0, sizeof(mask));
1918 for (pos = 0; pos < wow->patterns[i].pattern_len; pos++) {
1919 if (wow->patterns[i].mask[pos / 8] & (0x1 << (pos % 8)))
1923 * Note: Pattern's offset is not passed as part of wowlan
1924 * parameter from CFG layer. So it's always passed as ZERO
1925 * to the firmware. It means, given WOW patterns are always
1926 * matched from the first byte of received pkt in the firmware.
1928 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1929 vif->fw_vif_idx, WOW_LIST_ID,
1930 wow->patterns[i].pattern_len,
1931 0 /* pattern offset */,
1932 wow->patterns[i].pattern, mask);
1937 if (wow->disconnect)
1938 *filter |= WOW_FILTER_OPTION_NWK_DISASSOC;
1941 *filter |= WOW_FILTER_OPTION_MAGIC_PACKET;
1943 if (wow->gtk_rekey_failure)
1944 *filter |= WOW_FILTER_OPTION_GTK_ERROR;
1946 if (wow->eap_identity_req)
1947 *filter |= WOW_FILTER_OPTION_EAP_REQ;
1949 if (wow->four_way_handshake)
1950 *filter |= WOW_FILTER_OPTION_8021X_4WAYHS;
1955 static int ath6kl_wow_ap(struct ath6kl *ar, struct ath6kl_vif *vif)
1957 static const u8 unicst_pattern[] = { 0x00, 0x00, 0x00,
1958 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1959 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1961 static const u8 unicst_mask[] = { 0x01, 0x00, 0x00,
1962 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1963 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1965 u8 unicst_offset = 0;
1966 static const u8 arp_pattern[] = { 0x08, 0x06 };
1967 static const u8 arp_mask[] = { 0xff, 0xff };
1969 static const u8 discvr_pattern[] = { 0xe0, 0x00, 0x00, 0xf8 };
1970 static const u8 discvr_mask[] = { 0xf0, 0x00, 0x00, 0xf8 };
1971 u8 discvr_offset = 38;
1972 static const u8 dhcp_pattern[] = { 0xff, 0xff, 0xff, 0xff,
1973 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1974 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
1975 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1976 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1977 0x00, 0x00, 0x00, 0x00, 0x00, 0x43 /* port 67 */ };
1978 static const u8 dhcp_mask[] = { 0xff, 0xff, 0xff, 0xff,
1979 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1980 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
1981 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1982 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1983 0x00, 0x00, 0x00, 0x00, 0xff, 0xff /* port 67 */ };
1987 /* Setup unicast IP, EAPOL-like and ARP pkt pattern */
1988 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1989 vif->fw_vif_idx, WOW_LIST_ID,
1990 sizeof(unicst_pattern), unicst_offset,
1991 unicst_pattern, unicst_mask);
1993 ath6kl_err("failed to add WOW unicast IP pattern\n");
1997 /* Setup all ARP pkt pattern */
1998 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1999 vif->fw_vif_idx, WOW_LIST_ID,
2000 sizeof(arp_pattern), arp_offset,
2001 arp_pattern, arp_mask);
2003 ath6kl_err("failed to add WOW ARP pattern\n");
2008 * Setup multicast pattern for mDNS 224.0.0.251,
2009 * SSDP 239.255.255.250 and LLMNR 224.0.0.252
2011 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2012 vif->fw_vif_idx, WOW_LIST_ID,
2013 sizeof(discvr_pattern), discvr_offset,
2014 discvr_pattern, discvr_mask);
2016 ath6kl_err("failed to add WOW mDNS/SSDP/LLMNR pattern\n");
2020 /* Setup all DHCP broadcast pkt pattern */
2021 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2022 vif->fw_vif_idx, WOW_LIST_ID,
2023 sizeof(dhcp_pattern), dhcp_offset,
2024 dhcp_pattern, dhcp_mask);
2026 ath6kl_err("failed to add WOW DHCP broadcast pattern\n");
2033 static int ath6kl_wow_sta(struct ath6kl *ar, struct ath6kl_vif *vif)
2035 struct net_device *ndev = vif->ndev;
2036 static const u8 discvr_pattern[] = { 0xe0, 0x00, 0x00, 0xf8 };
2037 static const u8 discvr_mask[] = { 0xf0, 0x00, 0x00, 0xf8 };
2038 u8 discvr_offset = 38;
2039 u8 mac_mask[ETH_ALEN];
2042 /* Setup unicast pkt pattern */
2043 eth_broadcast_addr(mac_mask);
2044 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2045 vif->fw_vif_idx, WOW_LIST_ID,
2046 ETH_ALEN, 0, ndev->dev_addr,
2049 ath6kl_err("failed to add WOW unicast pattern\n");
2054 * Setup multicast pattern for mDNS 224.0.0.251,
2055 * SSDP 239.255.255.250 and LLMNR 224.0.0.252
2057 if ((ndev->flags & IFF_ALLMULTI) ||
2058 (ndev->flags & IFF_MULTICAST && netdev_mc_count(ndev) > 0)) {
2059 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2060 vif->fw_vif_idx, WOW_LIST_ID,
2061 sizeof(discvr_pattern), discvr_offset,
2062 discvr_pattern, discvr_mask);
2064 ath6kl_err("failed to add WOW mDNS/SSDP/LLMNR pattern\n");
2072 static int is_hsleep_mode_procsed(struct ath6kl_vif *vif)
2074 return test_bit(HOST_SLEEP_MODE_CMD_PROCESSED, &vif->flags);
2077 static bool is_ctrl_ep_empty(struct ath6kl *ar)
2079 return !ar->tx_pending[ar->ctrl_ep];
2082 static int ath6kl_cfg80211_host_sleep(struct ath6kl *ar, struct ath6kl_vif *vif)
2086 clear_bit(HOST_SLEEP_MODE_CMD_PROCESSED, &vif->flags);
2088 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2089 ATH6KL_HOST_MODE_ASLEEP);
2093 left = wait_event_interruptible_timeout(ar->event_wq,
2094 is_hsleep_mode_procsed(vif),
2097 ath6kl_warn("timeout, didn't get host sleep cmd processed event\n");
2099 } else if (left < 0) {
2100 ath6kl_warn("error while waiting for host sleep cmd processed event %d\n",
2105 if (ar->tx_pending[ar->ctrl_ep]) {
2106 left = wait_event_interruptible_timeout(ar->event_wq,
2107 is_ctrl_ep_empty(ar),
2110 ath6kl_warn("clear wmi ctrl data timeout\n");
2112 } else if (left < 0) {
2113 ath6kl_warn("clear wmi ctrl data failed: %d\n", left);
2121 static int ath6kl_wow_suspend_vif(struct ath6kl_vif *vif,
2122 struct cfg80211_wowlan *wow, u32 *filter)
2124 struct ath6kl *ar = vif->ar;
2125 struct in_device *in_dev;
2126 struct in_ifaddr *ifa;
2129 __be32 ips[MAX_IP_ADDRS];
2132 if (!test_bit(NETDEV_MCAST_ALL_ON, &vif->flags) &&
2133 test_bit(ATH6KL_FW_CAPABILITY_WOW_MULTICAST_FILTER,
2134 ar->fw_capabilities)) {
2135 ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi,
2136 vif->fw_vif_idx, false);
2141 /* Clear existing WOW patterns */
2142 for (i = 0; i < WOW_MAX_FILTERS_PER_LIST; i++)
2143 ath6kl_wmi_del_wow_pattern_cmd(ar->wmi, vif->fw_vif_idx,
2147 * Skip the default WOW pattern configuration
2148 * if the driver receives any WOW patterns from
2152 ret = ath6kl_wow_usr(ar, vif, wow, filter);
2153 else if (vif->nw_type == AP_NETWORK)
2154 ret = ath6kl_wow_ap(ar, vif);
2156 ret = ath6kl_wow_sta(ar, vif);
2161 netif_stop_queue(vif->ndev);
2163 if (vif->nw_type != AP_NETWORK) {
2164 ret = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
2165 ATH6KL_MAX_WOW_LISTEN_INTL,
2170 /* Set listen interval x 15 times as bmiss time */
2171 bmiss_time = ATH6KL_MAX_WOW_LISTEN_INTL * 15;
2172 if (bmiss_time > ATH6KL_MAX_BMISS_TIME)
2173 bmiss_time = ATH6KL_MAX_BMISS_TIME;
2175 ret = ath6kl_wmi_bmisstime_cmd(ar->wmi, vif->fw_vif_idx,
2180 ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2181 0xFFFF, 0, 0xFFFF, 0, 0, 0,
2187 /* Setup own IP addr for ARP agent. */
2188 in_dev = __in_dev_get_rtnl(vif->ndev);
2192 ifa = in_dev->ifa_list;
2193 memset(&ips, 0, sizeof(ips));
2195 /* Configure IP addr only if IP address count < MAX_IP_ADDRS */
2196 while (index < MAX_IP_ADDRS && ifa) {
2197 ips[index] = ifa->ifa_local;
2198 ifa = ifa->ifa_next;
2203 ath6kl_err("total IP addr count is exceeding fw limit\n");
2207 ret = ath6kl_wmi_set_ip_cmd(ar->wmi, vif->fw_vif_idx, ips[0], ips[1]);
2209 ath6kl_err("fail to setup ip for arp agent\n");
2216 static int ath6kl_wow_suspend(struct ath6kl *ar, struct cfg80211_wowlan *wow)
2218 struct ath6kl_vif *first_vif, *vif;
2221 bool connected = false;
2223 /* enter / leave wow suspend on first vif always */
2224 first_vif = ath6kl_vif_first(ar);
2225 if (WARN_ON(!first_vif) ||
2226 !ath6kl_cfg80211_ready(first_vif))
2229 if (wow && (wow->n_patterns > WOW_MAX_FILTERS_PER_LIST))
2232 /* install filters for each connected vif */
2233 spin_lock_bh(&ar->list_lock);
2234 list_for_each_entry(vif, &ar->vif_list, list) {
2235 if (!test_bit(CONNECTED, &vif->flags) ||
2236 !ath6kl_cfg80211_ready(vif))
2240 ret = ath6kl_wow_suspend_vif(vif, wow, &filter);
2244 spin_unlock_bh(&ar->list_lock);
2251 ar->state = ATH6KL_STATE_SUSPENDING;
2253 ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, first_vif->fw_vif_idx,
2254 ATH6KL_WOW_MODE_ENABLE,
2256 WOW_HOST_REQ_DELAY);
2260 return ath6kl_cfg80211_host_sleep(ar, first_vif);
2263 static int ath6kl_wow_resume_vif(struct ath6kl_vif *vif)
2265 struct ath6kl *ar = vif->ar;
2268 if (vif->nw_type != AP_NETWORK) {
2269 ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2270 0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
2274 ret = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
2275 vif->listen_intvl_t, 0);
2279 ret = ath6kl_wmi_bmisstime_cmd(ar->wmi, vif->fw_vif_idx,
2280 vif->bmiss_time_t, 0);
2285 if (!test_bit(NETDEV_MCAST_ALL_OFF, &vif->flags) &&
2286 test_bit(ATH6KL_FW_CAPABILITY_WOW_MULTICAST_FILTER,
2287 ar->fw_capabilities)) {
2288 ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi,
2289 vif->fw_vif_idx, true);
2294 netif_wake_queue(vif->ndev);
2299 static int ath6kl_wow_resume(struct ath6kl *ar)
2301 struct ath6kl_vif *vif;
2304 vif = ath6kl_vif_first(ar);
2305 if (WARN_ON(!vif) ||
2306 !ath6kl_cfg80211_ready(vif))
2309 ar->state = ATH6KL_STATE_RESUMING;
2311 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2312 ATH6KL_HOST_MODE_AWAKE);
2314 ath6kl_warn("Failed to configure host sleep mode for wow resume: %d\n",
2319 spin_lock_bh(&ar->list_lock);
2320 list_for_each_entry(vif, &ar->vif_list, list) {
2321 if (!test_bit(CONNECTED, &vif->flags) ||
2322 !ath6kl_cfg80211_ready(vif))
2324 ret = ath6kl_wow_resume_vif(vif);
2328 spin_unlock_bh(&ar->list_lock);
2333 ar->state = ATH6KL_STATE_ON;
2337 ar->state = ATH6KL_STATE_WOW;
2341 static int ath6kl_cfg80211_deepsleep_suspend(struct ath6kl *ar)
2343 struct ath6kl_vif *vif;
2346 vif = ath6kl_vif_first(ar);
2350 if (!test_bit(WMI_READY, &ar->flag)) {
2351 ath6kl_err("deepsleep failed as wmi is not ready\n");
2355 ath6kl_cfg80211_stop_all(ar);
2357 /* Save the current power mode before enabling power save */
2358 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
2360 ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER);
2364 /* Disable WOW mode */
2365 ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx,
2366 ATH6KL_WOW_MODE_DISABLE,
2371 /* Flush all non control pkts in TX path */
2372 ath6kl_tx_data_cleanup(ar);
2374 ret = ath6kl_cfg80211_host_sleep(ar, vif);
2381 static int ath6kl_cfg80211_deepsleep_resume(struct ath6kl *ar)
2383 struct ath6kl_vif *vif;
2386 vif = ath6kl_vif_first(ar);
2391 if (ar->wmi->pwr_mode != ar->wmi->saved_pwr_mode) {
2392 ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0,
2393 ar->wmi->saved_pwr_mode);
2398 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2399 ATH6KL_HOST_MODE_AWAKE);
2403 ar->state = ATH6KL_STATE_ON;
2405 /* Reset scan parameter to default values */
2406 ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2407 0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
2414 int ath6kl_cfg80211_suspend(struct ath6kl *ar,
2415 enum ath6kl_cfg_suspend_mode mode,
2416 struct cfg80211_wowlan *wow)
2418 struct ath6kl_vif *vif;
2419 enum ath6kl_state prev_state;
2423 case ATH6KL_CFG_SUSPEND_WOW:
2425 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode suspend\n");
2427 /* Flush all non control pkts in TX path */
2428 ath6kl_tx_data_cleanup(ar);
2430 prev_state = ar->state;
2432 ret = ath6kl_wow_suspend(ar, wow);
2434 ar->state = prev_state;
2438 ar->state = ATH6KL_STATE_WOW;
2441 case ATH6KL_CFG_SUSPEND_DEEPSLEEP:
2443 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "deep sleep suspend\n");
2445 ret = ath6kl_cfg80211_deepsleep_suspend(ar);
2447 ath6kl_err("deepsleep suspend failed: %d\n", ret);
2451 ar->state = ATH6KL_STATE_DEEPSLEEP;
2455 case ATH6KL_CFG_SUSPEND_CUTPOWER:
2457 ath6kl_cfg80211_stop_all(ar);
2459 if (ar->state == ATH6KL_STATE_OFF) {
2460 ath6kl_dbg(ATH6KL_DBG_SUSPEND,
2461 "suspend hw off, no action for cutpower\n");
2465 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "suspend cutting power\n");
2467 ret = ath6kl_init_hw_stop(ar);
2469 ath6kl_warn("failed to stop hw during suspend: %d\n",
2473 ar->state = ATH6KL_STATE_CUTPOWER;
2481 list_for_each_entry(vif, &ar->vif_list, list)
2482 ath6kl_cfg80211_scan_complete_event(vif, true);
2486 EXPORT_SYMBOL(ath6kl_cfg80211_suspend);
2488 int ath6kl_cfg80211_resume(struct ath6kl *ar)
2492 switch (ar->state) {
2493 case ATH6KL_STATE_WOW:
2494 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode resume\n");
2496 ret = ath6kl_wow_resume(ar);
2498 ath6kl_warn("wow mode resume failed: %d\n", ret);
2504 case ATH6KL_STATE_DEEPSLEEP:
2505 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "deep sleep resume\n");
2507 ret = ath6kl_cfg80211_deepsleep_resume(ar);
2509 ath6kl_warn("deep sleep resume failed: %d\n", ret);
2514 case ATH6KL_STATE_CUTPOWER:
2515 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "resume restoring power\n");
2517 ret = ath6kl_init_hw_start(ar);
2519 ath6kl_warn("Failed to boot hw in resume: %d\n", ret);
2530 EXPORT_SYMBOL(ath6kl_cfg80211_resume);
2534 /* hif layer decides what suspend mode to use */
2535 static int __ath6kl_cfg80211_suspend(struct wiphy *wiphy,
2536 struct cfg80211_wowlan *wow)
2538 struct ath6kl *ar = wiphy_priv(wiphy);
2540 ath6kl_recovery_suspend(ar);
2542 return ath6kl_hif_suspend(ar, wow);
2545 static int __ath6kl_cfg80211_resume(struct wiphy *wiphy)
2547 struct ath6kl *ar = wiphy_priv(wiphy);
2550 err = ath6kl_hif_resume(ar);
2554 ath6kl_recovery_resume(ar);
2560 * FIXME: WOW suspend mode is selected if the host sdio controller supports
2561 * both sdio irq wake up and keep power. The target pulls sdio data line to
2562 * wake up the host when WOW pattern matches. This causes sdio irq handler
2563 * is being called in the host side which internally hits ath6kl's RX path.
2565 * Since sdio interrupt is not disabled, RX path executes even before
2566 * the host executes the actual resume operation from PM module.
2568 * In the current scenario, WOW resume should happen before start processing
2569 * any data from the target. So It's required to perform WOW resume in RX path.
2570 * Ideally we should perform WOW resume only in the actual platform
2571 * resume path. This area needs bit rework to avoid WOW resume in RX path.
2573 * ath6kl_check_wow_status() is called from ath6kl_rx().
2575 void ath6kl_check_wow_status(struct ath6kl *ar)
2577 if (ar->state == ATH6KL_STATE_SUSPENDING)
2580 if (ar->state == ATH6KL_STATE_WOW)
2581 ath6kl_cfg80211_resume(ar);
2586 void ath6kl_check_wow_status(struct ath6kl *ar)
2591 static int ath6kl_set_htcap(struct ath6kl_vif *vif, enum nl80211_band band,
2594 struct ath6kl_htcap *htcap = &vif->htcap[band];
2596 if (htcap->ht_enable == ht_enable)
2600 /* Set default ht capabilities */
2601 htcap->ht_enable = true;
2602 htcap->cap_info = (band == NL80211_BAND_2GHZ) ?
2603 ath6kl_g_htcap : ath6kl_a_htcap;
2604 htcap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K;
2605 } else /* Disable ht */
2606 memset(htcap, 0, sizeof(*htcap));
2608 return ath6kl_wmi_set_htcap_cmd(vif->ar->wmi, vif->fw_vif_idx,
2612 static int ath6kl_restore_htcap(struct ath6kl_vif *vif)
2614 struct wiphy *wiphy = vif->ar->wiphy;
2617 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2618 if (!wiphy->bands[band])
2621 ret = ath6kl_set_htcap(vif, band,
2622 wiphy->bands[band]->ht_cap.ht_supported);
2630 static bool ath6kl_is_p2p_ie(const u8 *pos)
2632 return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
2633 pos[2] == 0x50 && pos[3] == 0x6f &&
2634 pos[4] == 0x9a && pos[5] == 0x09;
2637 static int ath6kl_set_ap_probe_resp_ies(struct ath6kl_vif *vif,
2638 const u8 *ies, size_t ies_len)
2640 struct ath6kl *ar = vif->ar;
2647 * Filter out P2P IE(s) since they will be included depending on
2648 * the Probe Request frame in ath6kl_send_go_probe_resp().
2651 if (ies && ies_len) {
2652 buf = kmalloc(ies_len, GFP_KERNEL);
2656 while (pos + 1 < ies + ies_len) {
2657 if (pos + 2 + pos[1] > ies + ies_len)
2659 if (!ath6kl_is_p2p_ie(pos)) {
2660 memcpy(buf + len, pos, 2 + pos[1]);
2667 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2668 WMI_FRAME_PROBE_RESP, buf, len);
2673 static int ath6kl_set_ies(struct ath6kl_vif *vif,
2674 struct cfg80211_beacon_data *info)
2676 struct ath6kl *ar = vif->ar;
2679 /* this also clears IE in fw if it's not set */
2680 res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2683 info->beacon_ies_len);
2687 /* this also clears IE in fw if it's not set */
2688 res = ath6kl_set_ap_probe_resp_ies(vif, info->proberesp_ies,
2689 info->proberesp_ies_len);
2693 /* this also clears IE in fw if it's not set */
2694 res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2695 WMI_FRAME_ASSOC_RESP,
2696 info->assocresp_ies,
2697 info->assocresp_ies_len);
2704 static int ath6kl_get_rsn_capab(struct cfg80211_beacon_data *beacon,
2714 rsn_ie = cfg80211_find_ie(WLAN_EID_RSN, beacon->tail, beacon->tail_len);
2718 rsn_ie_len = *(rsn_ie + 1);
2719 /* skip element id and length */
2728 /* skip group cipher suite */
2734 /* skip pairwise cipher suite */
2737 cnt = get_unaligned_le16(rsn_ie);
2738 rsn_ie += (2 + cnt * 4);
2739 rsn_ie_len -= (2 + cnt * 4);
2741 /* skip akm suite */
2744 cnt = get_unaligned_le16(rsn_ie);
2745 rsn_ie += (2 + cnt * 4);
2746 rsn_ie_len -= (2 + cnt * 4);
2751 memcpy(rsn_capab, rsn_ie, 2);
2756 static int ath6kl_start_ap(struct wiphy *wiphy, struct net_device *dev,
2757 struct cfg80211_ap_settings *info)
2759 struct ath6kl *ar = ath6kl_priv(dev);
2760 struct ath6kl_vif *vif = netdev_priv(dev);
2761 struct ieee80211_mgmt *mgmt;
2762 bool hidden = false;
2765 struct wmi_connect_cmd p;
2769 int inactivity_timeout = 0;
2771 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s:\n", __func__);
2773 if (!ath6kl_cfg80211_ready(vif))
2776 if (vif->next_mode != AP_NETWORK)
2779 res = ath6kl_set_ies(vif, &info->beacon);
2781 ar->ap_mode_bkey.valid = false;
2783 ret = ath6kl_wmi_ap_set_beacon_intvl_cmd(ar->wmi, vif->fw_vif_idx,
2784 info->beacon_interval);
2787 ath6kl_warn("Failed to set beacon interval: %d\n", ret);
2789 ret = ath6kl_wmi_ap_set_dtim_cmd(ar->wmi, vif->fw_vif_idx,
2792 /* ignore error, just print a warning and continue normally */
2794 ath6kl_warn("Failed to set dtim_period in beacon: %d\n", ret);
2796 if (info->beacon.head == NULL)
2798 mgmt = (struct ieee80211_mgmt *) info->beacon.head;
2799 ies = mgmt->u.beacon.variable;
2800 if (ies > info->beacon.head + info->beacon.head_len)
2802 ies_len = info->beacon.head + info->beacon.head_len - ies;
2804 if (info->ssid == NULL)
2806 memcpy(vif->ssid, info->ssid, info->ssid_len);
2807 vif->ssid_len = info->ssid_len;
2808 if (info->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE)
2811 res = ath6kl_wmi_ap_hidden_ssid(ar->wmi, vif->fw_vif_idx, hidden);
2815 ret = ath6kl_set_auth_type(vif, info->auth_type);
2819 memset(&p, 0, sizeof(p));
2821 for (i = 0; i < info->crypto.n_akm_suites; i++) {
2822 switch (info->crypto.akm_suites[i]) {
2823 case WLAN_AKM_SUITE_8021X:
2824 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2825 p.auth_mode |= WPA_AUTH;
2826 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2827 p.auth_mode |= WPA2_AUTH;
2829 case WLAN_AKM_SUITE_PSK:
2830 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2831 p.auth_mode |= WPA_PSK_AUTH;
2832 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2833 p.auth_mode |= WPA2_PSK_AUTH;
2837 if (p.auth_mode == 0)
2838 p.auth_mode = NONE_AUTH;
2839 vif->auth_mode = p.auth_mode;
2841 for (i = 0; i < info->crypto.n_ciphers_pairwise; i++) {
2842 switch (info->crypto.ciphers_pairwise[i]) {
2843 case WLAN_CIPHER_SUITE_WEP40:
2844 case WLAN_CIPHER_SUITE_WEP104:
2845 p.prwise_crypto_type |= WEP_CRYPT;
2847 case WLAN_CIPHER_SUITE_TKIP:
2848 p.prwise_crypto_type |= TKIP_CRYPT;
2850 case WLAN_CIPHER_SUITE_CCMP:
2851 p.prwise_crypto_type |= AES_CRYPT;
2853 case WLAN_CIPHER_SUITE_SMS4:
2854 p.prwise_crypto_type |= WAPI_CRYPT;
2858 if (p.prwise_crypto_type == 0) {
2859 p.prwise_crypto_type = NONE_CRYPT;
2860 ath6kl_set_cipher(vif, 0, true);
2861 } else if (info->crypto.n_ciphers_pairwise == 1) {
2862 ath6kl_set_cipher(vif, info->crypto.ciphers_pairwise[0], true);
2865 switch (info->crypto.cipher_group) {
2866 case WLAN_CIPHER_SUITE_WEP40:
2867 case WLAN_CIPHER_SUITE_WEP104:
2868 p.grp_crypto_type = WEP_CRYPT;
2870 case WLAN_CIPHER_SUITE_TKIP:
2871 p.grp_crypto_type = TKIP_CRYPT;
2873 case WLAN_CIPHER_SUITE_CCMP:
2874 p.grp_crypto_type = AES_CRYPT;
2876 case WLAN_CIPHER_SUITE_SMS4:
2877 p.grp_crypto_type = WAPI_CRYPT;
2880 p.grp_crypto_type = NONE_CRYPT;
2883 ath6kl_set_cipher(vif, info->crypto.cipher_group, false);
2885 p.nw_type = AP_NETWORK;
2886 vif->nw_type = vif->next_mode;
2888 p.ssid_len = vif->ssid_len;
2889 memcpy(p.ssid, vif->ssid, vif->ssid_len);
2890 p.dot11_auth_mode = vif->dot11_auth_mode;
2891 p.ch = cpu_to_le16(info->chandef.chan->center_freq);
2893 /* Enable uAPSD support by default */
2894 res = ath6kl_wmi_ap_set_apsd(ar->wmi, vif->fw_vif_idx, true);
2898 if (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
2899 p.nw_subtype = SUBTYPE_P2PGO;
2902 * Due to firmware limitation, it is not possible to
2903 * do P2P mgmt operations in AP mode
2905 p.nw_subtype = SUBTYPE_NONE;
2908 if (info->inactivity_timeout) {
2909 inactivity_timeout = info->inactivity_timeout;
2911 if (test_bit(ATH6KL_FW_CAPABILITY_AP_INACTIVITY_MINS,
2912 ar->fw_capabilities))
2913 inactivity_timeout = DIV_ROUND_UP(inactivity_timeout,
2916 res = ath6kl_wmi_set_inact_period(ar->wmi, vif->fw_vif_idx,
2917 inactivity_timeout);
2922 if (ath6kl_set_htcap(vif, info->chandef.chan->band,
2923 cfg80211_get_chandef_type(&info->chandef)
2924 != NL80211_CHAN_NO_HT))
2928 * Get the PTKSA replay counter in the RSN IE. Supplicant
2929 * will use the RSN IE in M3 message and firmware has to
2930 * advertise the same in beacon/probe response. Send
2931 * the complete RSN IE capability field to firmware
2933 if (!ath6kl_get_rsn_capab(&info->beacon, (u8 *) &rsn_capab) &&
2934 test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
2935 ar->fw_capabilities)) {
2936 res = ath6kl_wmi_set_ie_cmd(ar->wmi, vif->fw_vif_idx,
2937 WLAN_EID_RSN, WMI_RSN_IE_CAPB,
2938 (const u8 *) &rsn_capab,
2940 vif->rsn_capab = rsn_capab;
2945 memcpy(&vif->profile, &p, sizeof(p));
2946 res = ath6kl_wmi_ap_profile_commit(ar->wmi, vif->fw_vif_idx, &p);
2953 static int ath6kl_change_beacon(struct wiphy *wiphy, struct net_device *dev,
2954 struct cfg80211_beacon_data *beacon)
2956 struct ath6kl_vif *vif = netdev_priv(dev);
2958 if (!ath6kl_cfg80211_ready(vif))
2961 if (vif->next_mode != AP_NETWORK)
2964 return ath6kl_set_ies(vif, beacon);
2967 static int ath6kl_stop_ap(struct wiphy *wiphy, struct net_device *dev)
2969 struct ath6kl *ar = ath6kl_priv(dev);
2970 struct ath6kl_vif *vif = netdev_priv(dev);
2972 if (vif->nw_type != AP_NETWORK)
2974 if (!test_bit(CONNECTED, &vif->flags))
2977 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
2978 clear_bit(CONNECTED, &vif->flags);
2979 netif_carrier_off(vif->ndev);
2981 /* Restore ht setting in firmware */
2982 return ath6kl_restore_htcap(vif);
2985 static const u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2987 static int ath6kl_del_station(struct wiphy *wiphy, struct net_device *dev,
2988 struct station_del_parameters *params)
2990 struct ath6kl *ar = ath6kl_priv(dev);
2991 struct ath6kl_vif *vif = netdev_priv(dev);
2992 const u8 *addr = params->mac ? params->mac : bcast_addr;
2994 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx, WMI_AP_DEAUTH,
2995 addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
2998 static int ath6kl_change_station(struct wiphy *wiphy, struct net_device *dev,
3000 struct station_parameters *params)
3002 struct ath6kl *ar = ath6kl_priv(dev);
3003 struct ath6kl_vif *vif = netdev_priv(dev);
3006 if (vif->nw_type != AP_NETWORK)
3009 err = cfg80211_check_station_change(wiphy, params,
3010 CFG80211_STA_AP_MLME_CLIENT);
3014 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
3015 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
3016 WMI_AP_MLME_AUTHORIZE, mac, 0);
3017 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
3018 WMI_AP_MLME_UNAUTHORIZE, mac, 0);
3021 static int ath6kl_remain_on_channel(struct wiphy *wiphy,
3022 struct wireless_dev *wdev,
3023 struct ieee80211_channel *chan,
3024 unsigned int duration,
3027 struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3028 struct ath6kl *ar = ath6kl_priv(vif->ndev);
3031 /* TODO: if already pending or ongoing remain-on-channel,
3033 id = ++vif->last_roc_id;
3035 /* Do not use 0 as the cookie value */
3036 id = ++vif->last_roc_id;
3040 return ath6kl_wmi_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx,
3041 chan->center_freq, duration);
3044 static int ath6kl_cancel_remain_on_channel(struct wiphy *wiphy,
3045 struct wireless_dev *wdev,
3048 struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3049 struct ath6kl *ar = ath6kl_priv(vif->ndev);
3051 if (cookie != vif->last_roc_id)
3053 vif->last_cancel_roc_id = cookie;
3055 return ath6kl_wmi_cancel_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx);
3058 static int ath6kl_send_go_probe_resp(struct ath6kl_vif *vif,
3059 const u8 *buf, size_t len,
3062 struct ath6kl *ar = vif->ar;
3067 const struct ieee80211_mgmt *mgmt;
3069 mgmt = (const struct ieee80211_mgmt *) buf;
3071 /* Include P2P IE(s) from the frame generated in user space. */
3073 p2p = kmalloc(len, GFP_KERNEL);
3078 pos = mgmt->u.probe_resp.variable;
3079 while (pos + 1 < buf + len) {
3080 if (pos + 2 + pos[1] > buf + len)
3082 if (ath6kl_is_p2p_ie(pos)) {
3083 memcpy(p2p + p2p_len, pos, 2 + pos[1]);
3084 p2p_len += 2 + pos[1];
3089 ret = ath6kl_wmi_send_probe_response_cmd(ar->wmi, vif->fw_vif_idx, freq,
3090 mgmt->da, p2p, p2p_len);
3095 static bool ath6kl_mgmt_powersave_ap(struct ath6kl_vif *vif,
3104 struct ieee80211_mgmt *mgmt;
3105 struct ath6kl_sta *conn;
3106 bool is_psq_empty = false;
3107 struct ath6kl_mgmt_buff *mgmt_buf;
3108 size_t mgmt_buf_size;
3109 struct ath6kl *ar = vif->ar;
3111 mgmt = (struct ieee80211_mgmt *) buf;
3112 if (is_multicast_ether_addr(mgmt->da))
3115 conn = ath6kl_find_sta(vif, mgmt->da);
3119 if (conn->sta_flags & STA_PS_SLEEP) {
3120 if (!(conn->sta_flags & STA_PS_POLLED)) {
3121 /* Queue the frames if the STA is sleeping */
3122 mgmt_buf_size = len + sizeof(struct ath6kl_mgmt_buff);
3123 mgmt_buf = kmalloc(mgmt_buf_size, GFP_KERNEL);
3127 INIT_LIST_HEAD(&mgmt_buf->list);
3129 mgmt_buf->freq = freq;
3130 mgmt_buf->wait = wait;
3131 mgmt_buf->len = len;
3132 mgmt_buf->no_cck = no_cck;
3133 memcpy(mgmt_buf->buf, buf, len);
3134 spin_lock_bh(&conn->psq_lock);
3135 is_psq_empty = skb_queue_empty(&conn->psq) &&
3136 (conn->mgmt_psq_len == 0);
3137 list_add_tail(&mgmt_buf->list, &conn->mgmt_psq);
3138 conn->mgmt_psq_len++;
3139 spin_unlock_bh(&conn->psq_lock);
3142 * If this is the first pkt getting queued
3143 * for this STA, update the PVB for this
3147 ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx,
3153 * This tx is because of a PsPoll.
3154 * Determine if MoreData bit has to be set.
3156 spin_lock_bh(&conn->psq_lock);
3157 if (!skb_queue_empty(&conn->psq) || (conn->mgmt_psq_len != 0))
3159 spin_unlock_bh(&conn->psq_lock);
3165 /* Check if SSID length is greater than DIRECT- */
3166 static bool ath6kl_is_p2p_go_ssid(const u8 *buf, size_t len)
3168 const struct ieee80211_mgmt *mgmt;
3169 mgmt = (const struct ieee80211_mgmt *) buf;
3171 /* variable[1] contains the SSID tag length */
3172 if (buf + len >= &mgmt->u.probe_resp.variable[1] &&
3173 (mgmt->u.probe_resp.variable[1] > P2P_WILDCARD_SSID_LEN)) {
3180 static int ath6kl_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
3181 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
3183 struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3184 struct ath6kl *ar = ath6kl_priv(vif->ndev);
3185 struct ieee80211_channel *chan = params->chan;
3186 const u8 *buf = params->buf;
3187 size_t len = params->len;
3188 unsigned int wait = params->wait;
3189 bool no_cck = params->no_cck;
3191 const struct ieee80211_mgmt *mgmt;
3192 bool more_data, queued;
3194 /* default to the current channel, but use the one specified as argument
3197 freq = vif->ch_hint;
3199 freq = chan->center_freq;
3201 /* never send freq zero to the firmware */
3202 if (WARN_ON(freq == 0))
3205 mgmt = (const struct ieee80211_mgmt *) buf;
3206 if (vif->nw_type == AP_NETWORK && test_bit(CONNECTED, &vif->flags) &&
3207 ieee80211_is_probe_resp(mgmt->frame_control) &&
3208 ath6kl_is_p2p_go_ssid(buf, len)) {
3210 * Send Probe Response frame in GO mode using a separate WMI
3211 * command to allow the target to fill in the generic IEs.
3213 *cookie = 0; /* TX status not supported */
3214 return ath6kl_send_go_probe_resp(vif, buf, len, freq);
3217 id = vif->send_action_id++;
3220 * 0 is a reserved value in the WMI command and shall not be
3221 * used for the command.
3223 id = vif->send_action_id++;
3228 /* AP mode Power saving processing */
3229 if (vif->nw_type == AP_NETWORK) {
3230 queued = ath6kl_mgmt_powersave_ap(vif, id, freq, wait, buf, len,
3231 &more_data, no_cck);
3236 return ath6kl_wmi_send_mgmt_cmd(ar->wmi, vif->fw_vif_idx, id, freq,
3237 wait, buf, len, no_cck);
3240 static int ath6kl_get_antenna(struct wiphy *wiphy,
3241 u32 *tx_ant, u32 *rx_ant)
3243 struct ath6kl *ar = wiphy_priv(wiphy);
3244 *tx_ant = ar->hw.tx_ant;
3245 *rx_ant = ar->hw.rx_ant;
3249 static void ath6kl_mgmt_frame_register(struct wiphy *wiphy,
3250 struct wireless_dev *wdev,
3251 u16 frame_type, bool reg)
3253 struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3255 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: frame_type=0x%x reg=%d\n",
3256 __func__, frame_type, reg);
3257 if (frame_type == IEEE80211_STYPE_PROBE_REQ) {
3259 * Note: This notification callback is not allowed to sleep, so
3260 * we cannot send WMI_PROBE_REQ_REPORT_CMD here. Instead, we
3261 * hardcode target to report Probe Request frames all the time.
3263 vif->probe_req_report = reg;
3267 static int ath6kl_cfg80211_sscan_start(struct wiphy *wiphy,
3268 struct net_device *dev,
3269 struct cfg80211_sched_scan_request *request)
3271 struct ath6kl *ar = ath6kl_priv(dev);
3272 struct ath6kl_vif *vif = netdev_priv(dev);
3274 int ret, rssi_thold;
3275 int n_match_sets = request->n_match_sets;
3278 * If there's a matchset w/o an SSID, then assume it's just for
3279 * the RSSI (nothing else is currently supported) and ignore it.
3280 * The device only supports a global RSSI filter that we set below.
3282 if (n_match_sets == 1 && !request->match_sets[0].ssid.ssid_len)
3285 if (ar->state != ATH6KL_STATE_ON)
3288 if (vif->sme_state != SME_DISCONNECTED)
3291 ath6kl_cfg80211_scan_complete_event(vif, true);
3293 ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
3295 request->match_sets,
3300 if (!n_match_sets) {
3301 ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
3306 ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
3307 MATCHED_SSID_FILTER, 0);
3312 if (test_bit(ATH6KL_FW_CAPABILITY_RSSI_SCAN_THOLD,
3313 ar->fw_capabilities)) {
3314 if (request->min_rssi_thold <= NL80211_SCAN_RSSI_THOLD_OFF)
3316 else if (request->min_rssi_thold < -127)
3319 rssi_thold = request->min_rssi_thold;
3321 ret = ath6kl_wmi_set_rssi_filter_cmd(ar->wmi, vif->fw_vif_idx,
3324 ath6kl_err("failed to set RSSI threshold for scan\n");
3329 /* fw uses seconds, also make sure that it's >0 */
3330 interval = max_t(u16, 1, request->scan_plans[0].interval);
3332 ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
3334 vif->bg_scan_period, 0, 0, 0, 3, 0, 0, 0);
3336 /* this also clears IE in fw if it's not set */
3337 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
3338 WMI_FRAME_PROBE_REQ,
3339 request->ie, request->ie_len);
3341 ath6kl_warn("Failed to set probe request IE for scheduled scan: %d\n",
3346 ret = ath6kl_wmi_enable_sched_scan_cmd(ar->wmi, vif->fw_vif_idx, true);
3350 set_bit(SCHED_SCANNING, &vif->flags);
3355 static int ath6kl_cfg80211_sscan_stop(struct wiphy *wiphy,
3356 struct net_device *dev)
3358 struct ath6kl_vif *vif = netdev_priv(dev);
3361 stopped = __ath6kl_cfg80211_sscan_stop(vif);
3369 static int ath6kl_cfg80211_set_bitrate(struct wiphy *wiphy,
3370 struct net_device *dev,
3372 const struct cfg80211_bitrate_mask *mask)
3374 struct ath6kl *ar = ath6kl_priv(dev);
3375 struct ath6kl_vif *vif = netdev_priv(dev);
3377 return ath6kl_wmi_set_bitrate_mask(ar->wmi, vif->fw_vif_idx,
3381 static int ath6kl_cfg80211_set_txe_config(struct wiphy *wiphy,
3382 struct net_device *dev,
3383 u32 rate, u32 pkts, u32 intvl)
3385 struct ath6kl *ar = ath6kl_priv(dev);
3386 struct ath6kl_vif *vif = netdev_priv(dev);
3388 if (vif->nw_type != INFRA_NETWORK ||
3389 !test_bit(ATH6KL_FW_CAPABILITY_TX_ERR_NOTIFY, ar->fw_capabilities))
3392 if (vif->sme_state != SME_CONNECTED)
3395 /* save this since the firmware won't report the interval */
3396 vif->txe_intvl = intvl;
3398 return ath6kl_wmi_set_txe_notify(ar->wmi, vif->fw_vif_idx,
3402 static const struct ieee80211_txrx_stypes
3403 ath6kl_mgmt_stypes[NUM_NL80211_IFTYPES] = {
3404 [NL80211_IFTYPE_STATION] = {
3405 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3406 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3407 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3408 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3410 [NL80211_IFTYPE_AP] = {
3411 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3412 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3413 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3414 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3416 [NL80211_IFTYPE_P2P_CLIENT] = {
3417 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3418 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3419 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3420 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3422 [NL80211_IFTYPE_P2P_GO] = {
3423 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3424 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3425 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3426 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3430 static struct cfg80211_ops ath6kl_cfg80211_ops = {
3431 .add_virtual_intf = ath6kl_cfg80211_add_iface,
3432 .del_virtual_intf = ath6kl_cfg80211_del_iface,
3433 .change_virtual_intf = ath6kl_cfg80211_change_iface,
3434 .scan = ath6kl_cfg80211_scan,
3435 .connect = ath6kl_cfg80211_connect,
3436 .disconnect = ath6kl_cfg80211_disconnect,
3437 .add_key = ath6kl_cfg80211_add_key,
3438 .get_key = ath6kl_cfg80211_get_key,
3439 .del_key = ath6kl_cfg80211_del_key,
3440 .set_default_key = ath6kl_cfg80211_set_default_key,
3441 .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
3442 .set_tx_power = ath6kl_cfg80211_set_txpower,
3443 .get_tx_power = ath6kl_cfg80211_get_txpower,
3444 .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
3445 .join_ibss = ath6kl_cfg80211_join_ibss,
3446 .leave_ibss = ath6kl_cfg80211_leave_ibss,
3447 .get_station = ath6kl_get_station,
3448 .set_pmksa = ath6kl_set_pmksa,
3449 .del_pmksa = ath6kl_del_pmksa,
3450 .flush_pmksa = ath6kl_flush_pmksa,
3451 CFG80211_TESTMODE_CMD(ath6kl_tm_cmd)
3453 .suspend = __ath6kl_cfg80211_suspend,
3454 .resume = __ath6kl_cfg80211_resume,
3456 .start_ap = ath6kl_start_ap,
3457 .change_beacon = ath6kl_change_beacon,
3458 .stop_ap = ath6kl_stop_ap,
3459 .del_station = ath6kl_del_station,
3460 .change_station = ath6kl_change_station,
3461 .remain_on_channel = ath6kl_remain_on_channel,
3462 .cancel_remain_on_channel = ath6kl_cancel_remain_on_channel,
3463 .mgmt_tx = ath6kl_mgmt_tx,
3464 .mgmt_frame_register = ath6kl_mgmt_frame_register,
3465 .get_antenna = ath6kl_get_antenna,
3466 .sched_scan_start = ath6kl_cfg80211_sscan_start,
3467 .sched_scan_stop = ath6kl_cfg80211_sscan_stop,
3468 .set_bitrate_mask = ath6kl_cfg80211_set_bitrate,
3469 .set_cqm_txe_config = ath6kl_cfg80211_set_txe_config,
3472 void ath6kl_cfg80211_stop(struct ath6kl_vif *vif)
3474 ath6kl_cfg80211_sscan_disable(vif);
3476 switch (vif->sme_state) {
3477 case SME_DISCONNECTED:
3479 case SME_CONNECTING:
3480 cfg80211_connect_result(vif->ndev, vif->bssid, NULL, 0,
3482 WLAN_STATUS_UNSPECIFIED_FAILURE,
3486 cfg80211_disconnected(vif->ndev, 0, NULL, 0, true, GFP_KERNEL);
3490 if (vif->ar->state != ATH6KL_STATE_RECOVERY &&
3491 (test_bit(CONNECTED, &vif->flags) ||
3492 test_bit(CONNECT_PEND, &vif->flags)))
3493 ath6kl_wmi_disconnect_cmd(vif->ar->wmi, vif->fw_vif_idx);
3495 vif->sme_state = SME_DISCONNECTED;
3496 clear_bit(CONNECTED, &vif->flags);
3497 clear_bit(CONNECT_PEND, &vif->flags);
3499 /* Stop netdev queues, needed during recovery */
3500 netif_stop_queue(vif->ndev);
3501 netif_carrier_off(vif->ndev);
3503 /* disable scanning */
3504 if (vif->ar->state != ATH6KL_STATE_RECOVERY &&
3505 ath6kl_wmi_scanparams_cmd(vif->ar->wmi, vif->fw_vif_idx, 0xFFFF,
3506 0, 0, 0, 0, 0, 0, 0, 0, 0) != 0)
3507 ath6kl_warn("failed to disable scan during stop\n");
3509 ath6kl_cfg80211_scan_complete_event(vif, true);
3512 void ath6kl_cfg80211_stop_all(struct ath6kl *ar)
3514 struct ath6kl_vif *vif;
3516 vif = ath6kl_vif_first(ar);
3517 if (!vif && ar->state != ATH6KL_STATE_RECOVERY) {
3518 /* save the current power mode before enabling power save */
3519 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
3521 if (ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER) != 0)
3522 ath6kl_warn("ath6kl_deep_sleep_enable: wmi_powermode_cmd failed\n");
3527 * FIXME: we should take ar->list_lock to protect changes in the
3528 * vif_list, but that's not trivial to do as ath6kl_cfg80211_stop()
3531 list_for_each_entry(vif, &ar->vif_list, list)
3532 ath6kl_cfg80211_stop(vif);
3535 static void ath6kl_cfg80211_reg_notify(struct wiphy *wiphy,
3536 struct regulatory_request *request)
3538 struct ath6kl *ar = wiphy_priv(wiphy);
3539 u32 rates[NUM_NL80211_BANDS];
3542 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
3543 "cfg reg_notify %c%c%s%s initiator %d hint_type %d\n",
3544 request->alpha2[0], request->alpha2[1],
3545 request->intersect ? " intersect" : "",
3546 request->processed ? " processed" : "",
3547 request->initiator, request->user_reg_hint_type);
3549 if (request->user_reg_hint_type != NL80211_USER_REG_HINT_CELL_BASE)
3552 ret = ath6kl_wmi_set_regdomain_cmd(ar->wmi, request->alpha2);
3554 ath6kl_err("failed to set regdomain: %d\n", ret);
3559 * Firmware will apply the regdomain change only after a scan is
3560 * issued and it will send a WMI_REGDOMAIN_EVENTID when it has been
3564 for (i = 0; i < NUM_NL80211_BANDS; i++)
3565 if (wiphy->bands[i])
3566 rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
3569 ret = ath6kl_wmi_beginscan_cmd(ar->wmi, 0, WMI_LONG_SCAN, false,
3570 false, 0, ATH6KL_FG_SCAN_INTERVAL,
3571 0, NULL, false, rates);
3573 ath6kl_err("failed to start scan for a regdomain change: %d\n",
3579 static int ath6kl_cfg80211_vif_init(struct ath6kl_vif *vif)
3581 vif->aggr_cntxt = aggr_init(vif);
3582 if (!vif->aggr_cntxt) {
3583 ath6kl_err("failed to initialize aggr\n");
3587 setup_timer(&vif->disconnect_timer, disconnect_timer_handler,
3588 (unsigned long) vif->ndev);
3589 setup_timer(&vif->sched_scan_timer, ath6kl_wmi_sscan_timer,
3590 (unsigned long) vif);
3592 set_bit(WMM_ENABLED, &vif->flags);
3593 spin_lock_init(&vif->if_lock);
3595 INIT_LIST_HEAD(&vif->mc_filter);
3600 void ath6kl_cfg80211_vif_stop(struct ath6kl_vif *vif, bool wmi_ready)
3602 static u8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3605 netif_stop_queue(vif->ndev);
3607 clear_bit(WLAN_ENABLED, &vif->flags);
3610 discon_issued = test_bit(CONNECTED, &vif->flags) ||
3611 test_bit(CONNECT_PEND, &vif->flags);
3612 ath6kl_disconnect(vif);
3613 del_timer(&vif->disconnect_timer);
3616 ath6kl_disconnect_event(vif, DISCONNECT_CMD,
3617 (vif->nw_type & AP_NETWORK) ?
3618 bcast_mac : vif->bssid,
3622 if (vif->scan_req) {
3623 struct cfg80211_scan_info info = {
3627 cfg80211_scan_done(vif->scan_req, &info);
3628 vif->scan_req = NULL;
3631 /* need to clean up enhanced bmiss detection fw state */
3632 ath6kl_cfg80211_sta_bmiss_enhance(vif, false);
3635 void ath6kl_cfg80211_vif_cleanup(struct ath6kl_vif *vif)
3637 struct ath6kl *ar = vif->ar;
3638 struct ath6kl_mc_filter *mc_filter, *tmp;
3640 aggr_module_destroy(vif->aggr_cntxt);
3642 ar->avail_idx_map |= BIT(vif->fw_vif_idx);
3644 if (vif->nw_type == ADHOC_NETWORK)
3645 ar->ibss_if_active = false;
3647 list_for_each_entry_safe(mc_filter, tmp, &vif->mc_filter, list) {
3648 list_del(&mc_filter->list);
3652 unregister_netdevice(vif->ndev);
3657 static const char ath6kl_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
3658 /* Common stats names used by many drivers. */
3659 "tx_pkts_nic", "tx_bytes_nic", "rx_pkts_nic", "rx_bytes_nic",
3662 "d_tx_ucast_pkts", "d_tx_bcast_pkts",
3663 "d_tx_ucast_bytes", "d_tx_bcast_bytes",
3664 "d_tx_rts_ok", "d_tx_error", "d_tx_fail",
3665 "d_tx_retry", "d_tx_multi_retry", "d_tx_rts_fail",
3666 "d_tx_tkip_counter_measures",
3669 "d_rx_ucast_pkts", "d_rx_ucast_rate", "d_rx_bcast_pkts",
3670 "d_rx_ucast_bytes", "d_rx_bcast_bytes", "d_rx_frag_pkt",
3671 "d_rx_error", "d_rx_crc_err", "d_rx_keycache_miss",
3672 "d_rx_decrypt_crc_err", "d_rx_duplicate_frames",
3673 "d_rx_mic_err", "d_rx_tkip_format_err", "d_rx_ccmp_format_err",
3674 "d_rx_ccmp_replay_err",
3677 "d_beacon_miss", "d_num_connects", "d_num_disconnects",
3678 "d_beacon_avg_rssi", "d_arp_received", "d_arp_matched",
3682 #define ATH6KL_STATS_LEN ARRAY_SIZE(ath6kl_gstrings_sta_stats)
3684 static int ath6kl_get_sset_count(struct net_device *dev, int sset)
3688 if (sset == ETH_SS_STATS)
3689 rv += ATH6KL_STATS_LEN;
3696 static void ath6kl_get_stats(struct net_device *dev,
3697 struct ethtool_stats *stats,
3700 struct ath6kl_vif *vif = netdev_priv(dev);
3701 struct ath6kl *ar = vif->ar;
3703 struct target_stats *tgt_stats;
3705 memset(data, 0, sizeof(u64) * ATH6KL_STATS_LEN);
3707 ath6kl_read_tgt_stats(ar, vif);
3709 tgt_stats = &vif->target_stats;
3711 data[i++] = tgt_stats->tx_ucast_pkt + tgt_stats->tx_bcast_pkt;
3712 data[i++] = tgt_stats->tx_ucast_byte + tgt_stats->tx_bcast_byte;
3713 data[i++] = tgt_stats->rx_ucast_pkt + tgt_stats->rx_bcast_pkt;
3714 data[i++] = tgt_stats->rx_ucast_byte + tgt_stats->rx_bcast_byte;
3716 data[i++] = tgt_stats->tx_ucast_pkt;
3717 data[i++] = tgt_stats->tx_bcast_pkt;
3718 data[i++] = tgt_stats->tx_ucast_byte;
3719 data[i++] = tgt_stats->tx_bcast_byte;
3720 data[i++] = tgt_stats->tx_rts_success_cnt;
3721 data[i++] = tgt_stats->tx_err;
3722 data[i++] = tgt_stats->tx_fail_cnt;
3723 data[i++] = tgt_stats->tx_retry_cnt;
3724 data[i++] = tgt_stats->tx_mult_retry_cnt;
3725 data[i++] = tgt_stats->tx_rts_fail_cnt;
3726 data[i++] = tgt_stats->tkip_cnter_measures_invoked;
3728 data[i++] = tgt_stats->rx_ucast_pkt;
3729 data[i++] = tgt_stats->rx_ucast_rate;
3730 data[i++] = tgt_stats->rx_bcast_pkt;
3731 data[i++] = tgt_stats->rx_ucast_byte;
3732 data[i++] = tgt_stats->rx_bcast_byte;
3733 data[i++] = tgt_stats->rx_frgment_pkt;
3734 data[i++] = tgt_stats->rx_err;
3735 data[i++] = tgt_stats->rx_crc_err;
3736 data[i++] = tgt_stats->rx_key_cache_miss;
3737 data[i++] = tgt_stats->rx_decrypt_err;
3738 data[i++] = tgt_stats->rx_dupl_frame;
3739 data[i++] = tgt_stats->tkip_local_mic_fail;
3740 data[i++] = tgt_stats->tkip_fmt_err;
3741 data[i++] = tgt_stats->ccmp_fmt_err;
3742 data[i++] = tgt_stats->ccmp_replays;
3744 data[i++] = tgt_stats->cs_bmiss_cnt;
3745 data[i++] = tgt_stats->cs_connect_cnt;
3746 data[i++] = tgt_stats->cs_discon_cnt;
3747 data[i++] = tgt_stats->cs_ave_beacon_rssi;
3748 data[i++] = tgt_stats->arp_received;
3749 data[i++] = tgt_stats->arp_matched;
3750 data[i++] = tgt_stats->arp_replied;
3752 if (i != ATH6KL_STATS_LEN) {
3754 ath6kl_err("ethtool stats error, i: %d STATS_LEN: %d\n",
3755 i, (int)ATH6KL_STATS_LEN);
3759 /* These stats are per NIC, not really per vdev, so we just ignore dev. */
3760 static void ath6kl_get_strings(struct net_device *dev, u32 sset, u8 *data)
3762 int sz_sta_stats = 0;
3764 if (sset == ETH_SS_STATS) {
3765 sz_sta_stats = sizeof(ath6kl_gstrings_sta_stats);
3766 memcpy(data, ath6kl_gstrings_sta_stats, sz_sta_stats);
3770 static const struct ethtool_ops ath6kl_ethtool_ops = {
3771 .get_drvinfo = cfg80211_get_drvinfo,
3772 .get_link = ethtool_op_get_link,
3773 .get_strings = ath6kl_get_strings,
3774 .get_ethtool_stats = ath6kl_get_stats,
3775 .get_sset_count = ath6kl_get_sset_count,
3778 struct wireless_dev *ath6kl_interface_add(struct ath6kl *ar, const char *name,
3779 unsigned char name_assign_type,
3780 enum nl80211_iftype type,
3781 u8 fw_vif_idx, u8 nw_type)
3783 struct net_device *ndev;
3784 struct ath6kl_vif *vif;
3786 ndev = alloc_netdev(sizeof(*vif), name, name_assign_type, ether_setup);
3790 vif = netdev_priv(ndev);
3791 ndev->ieee80211_ptr = &vif->wdev;
3792 vif->wdev.wiphy = ar->wiphy;
3795 SET_NETDEV_DEV(ndev, wiphy_dev(vif->wdev.wiphy));
3796 vif->wdev.netdev = ndev;
3797 vif->wdev.iftype = type;
3798 vif->fw_vif_idx = fw_vif_idx;
3799 vif->nw_type = nw_type;
3800 vif->next_mode = nw_type;
3801 vif->listen_intvl_t = ATH6KL_DEFAULT_LISTEN_INTVAL;
3802 vif->bmiss_time_t = ATH6KL_DEFAULT_BMISS_TIME;
3803 vif->bg_scan_period = 0;
3804 vif->htcap[NL80211_BAND_2GHZ].ht_enable = true;
3805 vif->htcap[NL80211_BAND_5GHZ].ht_enable = true;
3807 memcpy(ndev->dev_addr, ar->mac_addr, ETH_ALEN);
3808 if (fw_vif_idx != 0) {
3809 ndev->dev_addr[0] = (ndev->dev_addr[0] ^ (1 << fw_vif_idx)) |
3811 if (test_bit(ATH6KL_FW_CAPABILITY_CUSTOM_MAC_ADDR,
3812 ar->fw_capabilities))
3813 ndev->dev_addr[4] ^= 0x80;
3818 ath6kl_init_control_info(vif);
3820 if (ath6kl_cfg80211_vif_init(vif))
3823 netdev_set_default_ethtool_ops(ndev, &ath6kl_ethtool_ops);
3825 if (register_netdevice(ndev))
3828 ar->avail_idx_map &= ~BIT(fw_vif_idx);
3829 vif->sme_state = SME_DISCONNECTED;
3830 set_bit(WLAN_ENABLED, &vif->flags);
3831 ar->wlan_pwr_state = WLAN_POWER_STATE_ON;
3833 if (type == NL80211_IFTYPE_ADHOC)
3834 ar->ibss_if_active = true;
3836 spin_lock_bh(&ar->list_lock);
3837 list_add_tail(&vif->list, &ar->vif_list);
3838 spin_unlock_bh(&ar->list_lock);
3843 aggr_module_destroy(vif->aggr_cntxt);
3849 static const struct wiphy_wowlan_support ath6kl_wowlan_support = {
3850 .flags = WIPHY_WOWLAN_MAGIC_PKT |
3851 WIPHY_WOWLAN_DISCONNECT |
3852 WIPHY_WOWLAN_GTK_REKEY_FAILURE |
3853 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
3854 WIPHY_WOWLAN_EAP_IDENTITY_REQ |
3855 WIPHY_WOWLAN_4WAY_HANDSHAKE,
3856 .n_patterns = WOW_MAX_FILTERS_PER_LIST,
3857 .pattern_min_len = 1,
3858 .pattern_max_len = WOW_PATTERN_SIZE,
3862 int ath6kl_cfg80211_init(struct ath6kl *ar)
3864 struct wiphy *wiphy = ar->wiphy;
3865 bool band_2gig = false, band_5gig = false, ht = false;
3868 wiphy->mgmt_stypes = ath6kl_mgmt_stypes;
3870 wiphy->max_remain_on_channel_duration = 5000;
3872 /* set device pointer for wiphy */
3873 set_wiphy_dev(wiphy, ar->dev);
3875 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3876 BIT(NL80211_IFTYPE_ADHOC) |
3877 BIT(NL80211_IFTYPE_AP);
3879 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_GO) |
3880 BIT(NL80211_IFTYPE_P2P_CLIENT);
3883 if (IS_ENABLED(CONFIG_ATH6KL_REGDOMAIN) &&
3884 test_bit(ATH6KL_FW_CAPABILITY_REGDOMAIN, ar->fw_capabilities)) {
3885 wiphy->reg_notifier = ath6kl_cfg80211_reg_notify;
3886 ar->wiphy->features |= NL80211_FEATURE_CELL_BASE_REG_HINTS;
3889 /* max num of ssids that can be probed during scanning */
3890 wiphy->max_scan_ssids = MAX_PROBED_SSIDS;
3892 /* max num of ssids that can be matched after scan */
3893 if (test_bit(ATH6KL_FW_CAPABILITY_SCHED_SCAN_MATCH_LIST,
3894 ar->fw_capabilities))
3895 wiphy->max_match_sets = MAX_PROBED_SSIDS;
3897 wiphy->max_scan_ie_len = 1000; /* FIX: what is correct limit? */
3898 switch (ar->hw.cap) {
3916 ath6kl_err("invalid phy capability!\n");
3921 * Even if the fw has HT support, advertise HT cap only when
3922 * the firmware has support to override RSN capability, otherwise
3923 * 4-way handshake would fail.
3926 test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
3927 ar->fw_capabilities))) {
3928 ath6kl_band_2ghz.ht_cap.cap = 0;
3929 ath6kl_band_2ghz.ht_cap.ht_supported = false;
3930 ath6kl_band_5ghz.ht_cap.cap = 0;
3931 ath6kl_band_5ghz.ht_cap.ht_supported = false;
3934 ath6kl_err("Firmware lacks RSN-CAP-OVERRIDE, so HT (802.11n) is disabled.");
3937 if (test_bit(ATH6KL_FW_CAPABILITY_64BIT_RATES,
3938 ar->fw_capabilities)) {
3939 ath6kl_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3940 ath6kl_band_5ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3941 ath6kl_band_2ghz.ht_cap.mcs.rx_mask[1] = 0xff;
3942 ath6kl_band_5ghz.ht_cap.mcs.rx_mask[1] = 0xff;
3943 ar->hw.tx_ant = 0x3; /* mask, 2 antenna */
3944 ar->hw.rx_ant = 0x3;
3946 ath6kl_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3947 ath6kl_band_5ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3952 wiphy->available_antennas_tx = ar->hw.tx_ant;
3953 wiphy->available_antennas_rx = ar->hw.rx_ant;
3956 wiphy->bands[NL80211_BAND_2GHZ] = &ath6kl_band_2ghz;
3958 wiphy->bands[NL80211_BAND_5GHZ] = &ath6kl_band_5ghz;
3960 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3962 wiphy->cipher_suites = cipher_suites;
3963 wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3966 wiphy->wowlan = &ath6kl_wowlan_support;
3969 wiphy->max_sched_scan_ssids = MAX_PROBED_SSIDS;
3971 ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM |
3972 WIPHY_FLAG_HAVE_AP_SME |
3973 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
3974 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
3976 if (test_bit(ATH6KL_FW_CAPABILITY_SCHED_SCAN_V2, ar->fw_capabilities))
3977 ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
3979 if (test_bit(ATH6KL_FW_CAPABILITY_INACTIVITY_TIMEOUT,
3980 ar->fw_capabilities))
3981 ar->wiphy->features |= NL80211_FEATURE_INACTIVITY_TIMER;
3983 ar->wiphy->probe_resp_offload =
3984 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
3985 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
3986 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
3988 ret = wiphy_register(wiphy);
3990 ath6kl_err("couldn't register wiphy device\n");
3994 ar->wiphy_registered = true;
3999 void ath6kl_cfg80211_cleanup(struct ath6kl *ar)
4001 wiphy_unregister(ar->wiphy);
4003 ar->wiphy_registered = false;
4006 struct ath6kl *ath6kl_cfg80211_create(void)
4009 struct wiphy *wiphy;
4011 /* create a new wiphy for use with cfg80211 */
4012 wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
4015 ath6kl_err("couldn't allocate wiphy device\n");
4019 ar = wiphy_priv(wiphy);
4025 /* Note: ar variable must not be accessed after calling this! */
4026 void ath6kl_cfg80211_destroy(struct ath6kl *ar)
4030 for (i = 0; i < AP_MAX_NUM_STA; i++)
4031 kfree(ar->sta_list[i].aggr_conn);
4033 wiphy_free(ar->wiphy);