1 /*
2  * Copyright (c) 2004-2011 Atheros Communications Inc.
3  * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 
20 #include <linux/moduleparam.h>
21 #include <linux/inetdevice.h>
22 #include <linux/export.h>
23 
24 #include "core.h"
25 #include "cfg80211.h"
26 #include "debug.h"
27 #include "hif-ops.h"
28 #include "testmode.h"
29 
30 #define RATETAB_ENT(_rate, _rateid, _flags) {   \
31 	.bitrate    = (_rate),                  \
32 	.flags      = (_flags),                 \
33 	.hw_value   = (_rateid),                \
34 }
35 
36 #define CHAN2G(_channel, _freq, _flags) {   \
37 	.band           = IEEE80211_BAND_2GHZ,  \
38 	.hw_value       = (_channel),           \
39 	.center_freq    = (_freq),              \
40 	.flags          = (_flags),             \
41 	.max_antenna_gain   = 0,                \
42 	.max_power      = 30,                   \
43 }
44 
45 #define CHAN5G(_channel, _flags) {		    \
46 	.band           = IEEE80211_BAND_5GHZ,      \
47 	.hw_value       = (_channel),               \
48 	.center_freq    = 5000 + (5 * (_channel)),  \
49 	.flags          = (_flags),                 \
50 	.max_antenna_gain   = 0,                    \
51 	.max_power      = 30,                       \
52 }
53 
54 #define DEFAULT_BG_SCAN_PERIOD 60
55 
56 struct ath6kl_cfg80211_match_probe_ssid {
57 	struct cfg80211_ssid ssid;
58 	u8 flag;
59 };
60 
61 static struct ieee80211_rate ath6kl_rates[] = {
62 	RATETAB_ENT(10, 0x1, 0),
63 	RATETAB_ENT(20, 0x2, 0),
64 	RATETAB_ENT(55, 0x4, 0),
65 	RATETAB_ENT(110, 0x8, 0),
66 	RATETAB_ENT(60, 0x10, 0),
67 	RATETAB_ENT(90, 0x20, 0),
68 	RATETAB_ENT(120, 0x40, 0),
69 	RATETAB_ENT(180, 0x80, 0),
70 	RATETAB_ENT(240, 0x100, 0),
71 	RATETAB_ENT(360, 0x200, 0),
72 	RATETAB_ENT(480, 0x400, 0),
73 	RATETAB_ENT(540, 0x800, 0),
74 };
75 
76 #define ath6kl_a_rates     (ath6kl_rates + 4)
77 #define ath6kl_a_rates_size    8
78 #define ath6kl_g_rates     (ath6kl_rates + 0)
79 #define ath6kl_g_rates_size    12
80 
81 #define ath6kl_g_htcap IEEE80211_HT_CAP_SGI_20
82 #define ath6kl_a_htcap (IEEE80211_HT_CAP_SUP_WIDTH_20_40 | \
83 			IEEE80211_HT_CAP_SGI_20		 | \
84 			IEEE80211_HT_CAP_SGI_40)
85 
86 static struct ieee80211_channel ath6kl_2ghz_channels[] = {
87 	CHAN2G(1, 2412, 0),
88 	CHAN2G(2, 2417, 0),
89 	CHAN2G(3, 2422, 0),
90 	CHAN2G(4, 2427, 0),
91 	CHAN2G(5, 2432, 0),
92 	CHAN2G(6, 2437, 0),
93 	CHAN2G(7, 2442, 0),
94 	CHAN2G(8, 2447, 0),
95 	CHAN2G(9, 2452, 0),
96 	CHAN2G(10, 2457, 0),
97 	CHAN2G(11, 2462, 0),
98 	CHAN2G(12, 2467, 0),
99 	CHAN2G(13, 2472, 0),
100 	CHAN2G(14, 2484, 0),
101 };
102 
103 static struct ieee80211_channel ath6kl_5ghz_a_channels[] = {
104 	CHAN5G(34, 0), CHAN5G(36, 0),
105 	CHAN5G(38, 0), CHAN5G(40, 0),
106 	CHAN5G(42, 0), CHAN5G(44, 0),
107 	CHAN5G(46, 0), CHAN5G(48, 0),
108 	CHAN5G(52, 0), CHAN5G(56, 0),
109 	CHAN5G(60, 0), CHAN5G(64, 0),
110 	CHAN5G(100, 0), CHAN5G(104, 0),
111 	CHAN5G(108, 0), CHAN5G(112, 0),
112 	CHAN5G(116, 0), CHAN5G(120, 0),
113 	CHAN5G(124, 0), CHAN5G(128, 0),
114 	CHAN5G(132, 0), CHAN5G(136, 0),
115 	CHAN5G(140, 0), CHAN5G(149, 0),
116 	CHAN5G(153, 0), CHAN5G(157, 0),
117 	CHAN5G(161, 0), CHAN5G(165, 0),
118 	CHAN5G(184, 0), CHAN5G(188, 0),
119 	CHAN5G(192, 0), CHAN5G(196, 0),
120 	CHAN5G(200, 0), CHAN5G(204, 0),
121 	CHAN5G(208, 0), CHAN5G(212, 0),
122 	CHAN5G(216, 0),
123 };
124 
125 static struct ieee80211_supported_band ath6kl_band_2ghz = {
126 	.n_channels = ARRAY_SIZE(ath6kl_2ghz_channels),
127 	.channels = ath6kl_2ghz_channels,
128 	.n_bitrates = ath6kl_g_rates_size,
129 	.bitrates = ath6kl_g_rates,
130 	.ht_cap.cap = ath6kl_g_htcap,
131 	.ht_cap.ht_supported = true,
132 };
133 
134 static struct ieee80211_supported_band ath6kl_band_5ghz = {
135 	.n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels),
136 	.channels = ath6kl_5ghz_a_channels,
137 	.n_bitrates = ath6kl_a_rates_size,
138 	.bitrates = ath6kl_a_rates,
139 	.ht_cap.cap = ath6kl_a_htcap,
140 	.ht_cap.ht_supported = true,
141 };
142 
143 #define CCKM_KRK_CIPHER_SUITE 0x004096ff /* use for KRK */
144 
145 /* returns true if scheduled scan was stopped */
146 static bool __ath6kl_cfg80211_sscan_stop(struct ath6kl_vif *vif)
147 {
148 	struct ath6kl *ar = vif->ar;
149 
150 	if (!test_and_clear_bit(SCHED_SCANNING, &vif->flags))
151 		return false;
152 
153 	del_timer_sync(&vif->sched_scan_timer);
154 
155 	if (ar->state == ATH6KL_STATE_RECOVERY)
156 		return true;
157 
158 	ath6kl_wmi_enable_sched_scan_cmd(ar->wmi, vif->fw_vif_idx, false);
159 
160 	return true;
161 }
162 
163 static void ath6kl_cfg80211_sscan_disable(struct ath6kl_vif *vif)
164 {
165 	struct ath6kl *ar = vif->ar;
166 	bool stopped;
167 
168 	stopped = __ath6kl_cfg80211_sscan_stop(vif);
169 
170 	if (!stopped)
171 		return;
172 
173 	cfg80211_sched_scan_stopped(ar->wiphy);
174 }
175 
176 static int ath6kl_set_wpa_version(struct ath6kl_vif *vif,
177 				  enum nl80211_wpa_versions wpa_version)
178 {
179 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
180 
181 	if (!wpa_version) {
182 		vif->auth_mode = NONE_AUTH;
183 	} else if (wpa_version & NL80211_WPA_VERSION_2) {
184 		vif->auth_mode = WPA2_AUTH;
185 	} else if (wpa_version & NL80211_WPA_VERSION_1) {
186 		vif->auth_mode = WPA_AUTH;
187 	} else {
188 		ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
189 		return -ENOTSUPP;
190 	}
191 
192 	return 0;
193 }
194 
195 static int ath6kl_set_auth_type(struct ath6kl_vif *vif,
196 				enum nl80211_auth_type auth_type)
197 {
198 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
199 
200 	switch (auth_type) {
201 	case NL80211_AUTHTYPE_OPEN_SYSTEM:
202 		vif->dot11_auth_mode = OPEN_AUTH;
203 		break;
204 	case NL80211_AUTHTYPE_SHARED_KEY:
205 		vif->dot11_auth_mode = SHARED_AUTH;
206 		break;
207 	case NL80211_AUTHTYPE_NETWORK_EAP:
208 		vif->dot11_auth_mode = LEAP_AUTH;
209 		break;
210 
211 	case NL80211_AUTHTYPE_AUTOMATIC:
212 		vif->dot11_auth_mode = OPEN_AUTH | SHARED_AUTH;
213 		break;
214 
215 	default:
216 		ath6kl_err("%s: 0x%x not supported\n", __func__, auth_type);
217 		return -ENOTSUPP;
218 	}
219 
220 	return 0;
221 }
222 
223 static int ath6kl_set_cipher(struct ath6kl_vif *vif, u32 cipher, bool ucast)
224 {
225 	u8 *ar_cipher = ucast ? &vif->prwise_crypto : &vif->grp_crypto;
226 	u8 *ar_cipher_len = ucast ? &vif->prwise_crypto_len :
227 		&vif->grp_crypto_len;
228 
229 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
230 		   __func__, cipher, ucast);
231 
232 	switch (cipher) {
233 	case 0:
234 		/* our own hack to use value 0 as no crypto used */
235 		*ar_cipher = NONE_CRYPT;
236 		*ar_cipher_len = 0;
237 		break;
238 	case WLAN_CIPHER_SUITE_WEP40:
239 		*ar_cipher = WEP_CRYPT;
240 		*ar_cipher_len = 5;
241 		break;
242 	case WLAN_CIPHER_SUITE_WEP104:
243 		*ar_cipher = WEP_CRYPT;
244 		*ar_cipher_len = 13;
245 		break;
246 	case WLAN_CIPHER_SUITE_TKIP:
247 		*ar_cipher = TKIP_CRYPT;
248 		*ar_cipher_len = 0;
249 		break;
250 	case WLAN_CIPHER_SUITE_CCMP:
251 		*ar_cipher = AES_CRYPT;
252 		*ar_cipher_len = 0;
253 		break;
254 	case WLAN_CIPHER_SUITE_SMS4:
255 		*ar_cipher = WAPI_CRYPT;
256 		*ar_cipher_len = 0;
257 		break;
258 	default:
259 		ath6kl_err("cipher 0x%x not supported\n", cipher);
260 		return -ENOTSUPP;
261 	}
262 
263 	return 0;
264 }
265 
266 static void ath6kl_set_key_mgmt(struct ath6kl_vif *vif, u32 key_mgmt)
267 {
268 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
269 
270 	if (key_mgmt == WLAN_AKM_SUITE_PSK) {
271 		if (vif->auth_mode == WPA_AUTH)
272 			vif->auth_mode = WPA_PSK_AUTH;
273 		else if (vif->auth_mode == WPA2_AUTH)
274 			vif->auth_mode = WPA2_PSK_AUTH;
275 	} else if (key_mgmt == 0x00409600) {
276 		if (vif->auth_mode == WPA_AUTH)
277 			vif->auth_mode = WPA_AUTH_CCKM;
278 		else if (vif->auth_mode == WPA2_AUTH)
279 			vif->auth_mode = WPA2_AUTH_CCKM;
280 	} else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
281 		vif->auth_mode = NONE_AUTH;
282 	}
283 }
284 
285 static bool ath6kl_cfg80211_ready(struct ath6kl_vif *vif)
286 {
287 	struct ath6kl *ar = vif->ar;
288 
289 	if (!test_bit(WMI_READY, &ar->flag)) {
290 		ath6kl_err("wmi is not ready\n");
291 		return false;
292 	}
293 
294 	if (!test_bit(WLAN_ENABLED, &vif->flags)) {
295 		ath6kl_err("wlan disabled\n");
296 		return false;
297 	}
298 
299 	return true;
300 }
301 
302 static bool ath6kl_is_wpa_ie(const u8 *pos)
303 {
304 	return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
305 		pos[2] == 0x00 && pos[3] == 0x50 &&
306 		pos[4] == 0xf2 && pos[5] == 0x01;
307 }
308 
309 static bool ath6kl_is_rsn_ie(const u8 *pos)
310 {
311 	return pos[0] == WLAN_EID_RSN;
312 }
313 
314 static bool ath6kl_is_wps_ie(const u8 *pos)
315 {
316 	return (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
317 		pos[1] >= 4 &&
318 		pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2 &&
319 		pos[5] == 0x04);
320 }
321 
322 static int ath6kl_set_assoc_req_ies(struct ath6kl_vif *vif, const u8 *ies,
323 				    size_t ies_len)
324 {
325 	struct ath6kl *ar = vif->ar;
326 	const u8 *pos;
327 	u8 *buf = NULL;
328 	size_t len = 0;
329 	int ret;
330 
331 	/*
332 	 * Clear previously set flag
333 	 */
334 
335 	ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
336 
337 	/*
338 	 * Filter out RSN/WPA IE(s)
339 	 */
340 
341 	if (ies && ies_len) {
342 		buf = kmalloc(ies_len, GFP_KERNEL);
343 		if (buf == NULL)
344 			return -ENOMEM;
345 		pos = ies;
346 
347 		while (pos + 1 < ies + ies_len) {
348 			if (pos + 2 + pos[1] > ies + ies_len)
349 				break;
350 			if (!(ath6kl_is_wpa_ie(pos) || ath6kl_is_rsn_ie(pos))) {
351 				memcpy(buf + len, pos, 2 + pos[1]);
352 				len += 2 + pos[1];
353 			}
354 
355 			if (ath6kl_is_wps_ie(pos))
356 				ar->connect_ctrl_flags |= CONNECT_WPS_FLAG;
357 
358 			pos += 2 + pos[1];
359 		}
360 	}
361 
362 	ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
363 				       WMI_FRAME_ASSOC_REQ, buf, len);
364 	kfree(buf);
365 	return ret;
366 }
367 
368 static int ath6kl_nliftype_to_drv_iftype(enum nl80211_iftype type, u8 *nw_type)
369 {
370 	switch (type) {
371 	case NL80211_IFTYPE_STATION:
372 	case NL80211_IFTYPE_P2P_CLIENT:
373 		*nw_type = INFRA_NETWORK;
374 		break;
375 	case NL80211_IFTYPE_ADHOC:
376 		*nw_type = ADHOC_NETWORK;
377 		break;
378 	case NL80211_IFTYPE_AP:
379 	case NL80211_IFTYPE_P2P_GO:
380 		*nw_type = AP_NETWORK;
381 		break;
382 	default:
383 		ath6kl_err("invalid interface type %u\n", type);
384 		return -ENOTSUPP;
385 	}
386 
387 	return 0;
388 }
389 
390 static bool ath6kl_is_valid_iftype(struct ath6kl *ar, enum nl80211_iftype type,
391 				   u8 *if_idx, u8 *nw_type)
392 {
393 	int i;
394 
395 	if (ath6kl_nliftype_to_drv_iftype(type, nw_type))
396 		return false;
397 
398 	if (ar->ibss_if_active || ((type == NL80211_IFTYPE_ADHOC) &&
399 				   ar->num_vif))
400 		return false;
401 
402 	if (type == NL80211_IFTYPE_STATION ||
403 	    type == NL80211_IFTYPE_AP || type == NL80211_IFTYPE_ADHOC) {
404 		for (i = 0; i < ar->vif_max; i++) {
405 			if ((ar->avail_idx_map) & BIT(i)) {
406 				*if_idx = i;
407 				return true;
408 			}
409 		}
410 	}
411 
412 	if (type == NL80211_IFTYPE_P2P_CLIENT ||
413 	    type == NL80211_IFTYPE_P2P_GO) {
414 		for (i = ar->max_norm_iface; i < ar->vif_max; i++) {
415 			if ((ar->avail_idx_map) & BIT(i)) {
416 				*if_idx = i;
417 				return true;
418 			}
419 		}
420 	}
421 
422 	return false;
423 }
424 
425 static bool ath6kl_is_tx_pending(struct ath6kl *ar)
426 {
427 	return ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0;
428 }
429 
430 static void ath6kl_cfg80211_sta_bmiss_enhance(struct ath6kl_vif *vif,
431 					      bool enable)
432 {
433 	int err;
434 
435 	if (WARN_ON(!test_bit(WMI_READY, &vif->ar->flag)))
436 		return;
437 
438 	if (vif->nw_type != INFRA_NETWORK)
439 		return;
440 
441 	if (!test_bit(ATH6KL_FW_CAPABILITY_BMISS_ENHANCE,
442 		      vif->ar->fw_capabilities))
443 		return;
444 
445 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s fw bmiss enhance\n",
446 		   enable ? "enable" : "disable");
447 
448 	err = ath6kl_wmi_sta_bmiss_enhance_cmd(vif->ar->wmi,
449 					       vif->fw_vif_idx, enable);
450 	if (err)
451 		ath6kl_err("failed to %s enhanced bmiss detection: %d\n",
452 			   enable ? "enable" : "disable", err);
453 }
454 
455 static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
456 				   struct cfg80211_connect_params *sme)
457 {
458 	struct ath6kl *ar = ath6kl_priv(dev);
459 	struct ath6kl_vif *vif = netdev_priv(dev);
460 	int status;
461 	u8 nw_subtype = (ar->p2p) ? SUBTYPE_P2PDEV : SUBTYPE_NONE;
462 	u16 interval;
463 
464 	ath6kl_cfg80211_sscan_disable(vif);
465 
466 	vif->sme_state = SME_CONNECTING;
467 
468 	if (!ath6kl_cfg80211_ready(vif))
469 		return -EIO;
470 
471 	if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
472 		ath6kl_err("destroy in progress\n");
473 		return -EBUSY;
474 	}
475 
476 	if (test_bit(SKIP_SCAN, &ar->flag) &&
477 	    ((sme->channel && sme->channel->center_freq == 0) ||
478 	     (sme->bssid && is_zero_ether_addr(sme->bssid)))) {
479 		ath6kl_err("SkipScan: channel or bssid invalid\n");
480 		return -EINVAL;
481 	}
482 
483 	if (down_interruptible(&ar->sem)) {
484 		ath6kl_err("busy, couldn't get access\n");
485 		return -ERESTARTSYS;
486 	}
487 
488 	if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
489 		ath6kl_err("busy, destroy in progress\n");
490 		up(&ar->sem);
491 		return -EBUSY;
492 	}
493 
494 	if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) {
495 		/*
496 		 * sleep until the command queue drains
497 		 */
498 		wait_event_interruptible_timeout(ar->event_wq,
499 						 ath6kl_is_tx_pending(ar),
500 						 WMI_TIMEOUT);
501 		if (signal_pending(current)) {
502 			ath6kl_err("cmd queue drain timeout\n");
503 			up(&ar->sem);
504 			return -EINTR;
505 		}
506 	}
507 
508 	status = ath6kl_set_assoc_req_ies(vif, sme->ie, sme->ie_len);
509 	if (status) {
510 		up(&ar->sem);
511 		return status;
512 	}
513 
514 	if (sme->ie == NULL || sme->ie_len == 0)
515 		ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
516 
517 	if (test_bit(CONNECTED, &vif->flags) &&
518 	    vif->ssid_len == sme->ssid_len &&
519 	    !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
520 		vif->reconnect_flag = true;
521 		status = ath6kl_wmi_reconnect_cmd(ar->wmi, vif->fw_vif_idx,
522 						  vif->req_bssid,
523 						  vif->ch_hint);
524 
525 		up(&ar->sem);
526 		if (status) {
527 			ath6kl_err("wmi_reconnect_cmd failed\n");
528 			return -EIO;
529 		}
530 		return 0;
531 	} else if (vif->ssid_len == sme->ssid_len &&
532 		   !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
533 		ath6kl_disconnect(vif);
534 	}
535 
536 	memset(vif->ssid, 0, sizeof(vif->ssid));
537 	vif->ssid_len = sme->ssid_len;
538 	memcpy(vif->ssid, sme->ssid, sme->ssid_len);
539 
540 	if (sme->channel)
541 		vif->ch_hint = sme->channel->center_freq;
542 
543 	memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
544 	if (sme->bssid && !is_broadcast_ether_addr(sme->bssid))
545 		memcpy(vif->req_bssid, sme->bssid, sizeof(vif->req_bssid));
546 
547 	ath6kl_set_wpa_version(vif, sme->crypto.wpa_versions);
548 
549 	status = ath6kl_set_auth_type(vif, sme->auth_type);
550 	if (status) {
551 		up(&ar->sem);
552 		return status;
553 	}
554 
555 	if (sme->crypto.n_ciphers_pairwise)
556 		ath6kl_set_cipher(vif, sme->crypto.ciphers_pairwise[0], true);
557 	else
558 		ath6kl_set_cipher(vif, 0, true);
559 
560 	ath6kl_set_cipher(vif, sme->crypto.cipher_group, false);
561 
562 	if (sme->crypto.n_akm_suites)
563 		ath6kl_set_key_mgmt(vif, sme->crypto.akm_suites[0]);
564 
565 	if ((sme->key_len) &&
566 	    (vif->auth_mode == NONE_AUTH) &&
567 	    (vif->prwise_crypto == WEP_CRYPT)) {
568 		struct ath6kl_key *key = NULL;
569 
570 		if (sme->key_idx > WMI_MAX_KEY_INDEX) {
571 			ath6kl_err("key index %d out of bounds\n",
572 				   sme->key_idx);
573 			up(&ar->sem);
574 			return -ENOENT;
575 		}
576 
577 		key = &vif->keys[sme->key_idx];
578 		key->key_len = sme->key_len;
579 		memcpy(key->key, sme->key, key->key_len);
580 		key->cipher = vif->prwise_crypto;
581 		vif->def_txkey_index = sme->key_idx;
582 
583 		ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, sme->key_idx,
584 				      vif->prwise_crypto,
585 				      GROUP_USAGE | TX_USAGE,
586 				      key->key_len,
587 				      NULL, 0,
588 				      key->key, KEY_OP_INIT_VAL, NULL,
589 				      NO_SYNC_WMIFLAG);
590 	}
591 
592 	if (!ar->usr_bss_filter) {
593 		clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
594 		if (ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
595 					     ALL_BSS_FILTER, 0) != 0) {
596 			ath6kl_err("couldn't set bss filtering\n");
597 			up(&ar->sem);
598 			return -EIO;
599 		}
600 	}
601 
602 	vif->nw_type = vif->next_mode;
603 
604 	/* enable enhanced bmiss detection if applicable */
605 	ath6kl_cfg80211_sta_bmiss_enhance(vif, true);
606 
607 	if (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT)
608 		nw_subtype = SUBTYPE_P2PCLIENT;
609 
610 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
611 		   "%s: connect called with authmode %d dot11 auth %d"
612 		   " PW crypto %d PW crypto len %d GRP crypto %d"
613 		   " GRP crypto len %d channel hint %u\n",
614 		   __func__,
615 		   vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
616 		   vif->prwise_crypto_len, vif->grp_crypto,
617 		   vif->grp_crypto_len, vif->ch_hint);
618 
619 	vif->reconnect_flag = 0;
620 
621 	if (vif->nw_type == INFRA_NETWORK) {
622 		interval = max_t(u16, vif->listen_intvl_t,
623 				 ATH6KL_MAX_WOW_LISTEN_INTL);
624 		status = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
625 						       interval,
626 						       0);
627 		if (status) {
628 			ath6kl_err("couldn't set listen intervel\n");
629 			up(&ar->sem);
630 			return status;
631 		}
632 	}
633 
634 	status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
635 					vif->dot11_auth_mode, vif->auth_mode,
636 					vif->prwise_crypto,
637 					vif->prwise_crypto_len,
638 					vif->grp_crypto, vif->grp_crypto_len,
639 					vif->ssid_len, vif->ssid,
640 					vif->req_bssid, vif->ch_hint,
641 					ar->connect_ctrl_flags, nw_subtype);
642 
643 	if (sme->bg_scan_period == 0) {
644 		/* disable background scan if period is 0 */
645 		sme->bg_scan_period = 0xffff;
646 	} else if (sme->bg_scan_period == -1) {
647 		/* configure default value if not specified */
648 		sme->bg_scan_period = DEFAULT_BG_SCAN_PERIOD;
649 	}
650 
651 	ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx, 0, 0,
652 				  sme->bg_scan_period, 0, 0, 0, 3, 0, 0, 0);
653 
654 	up(&ar->sem);
655 
656 	if (status == -EINVAL) {
657 		memset(vif->ssid, 0, sizeof(vif->ssid));
658 		vif->ssid_len = 0;
659 		ath6kl_err("invalid request\n");
660 		return -ENOENT;
661 	} else if (status) {
662 		ath6kl_err("ath6kl_wmi_connect_cmd failed\n");
663 		return -EIO;
664 	}
665 
666 	if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) &&
667 	    ((vif->auth_mode == WPA_PSK_AUTH) ||
668 	     (vif->auth_mode == WPA2_PSK_AUTH))) {
669 		mod_timer(&vif->disconnect_timer,
670 			  jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL));
671 	}
672 
673 	ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD;
674 	set_bit(CONNECT_PEND, &vif->flags);
675 
676 	return 0;
677 }
678 
679 static struct cfg80211_bss *
680 ath6kl_add_bss_if_needed(struct ath6kl_vif *vif,
681 			 enum network_type nw_type,
682 			 const u8 *bssid,
683 			 struct ieee80211_channel *chan,
684 			 const u8 *beacon_ie,
685 			 size_t beacon_ie_len)
686 {
687 	struct ath6kl *ar = vif->ar;
688 	struct cfg80211_bss *bss;
689 	u16 cap_val;
690 	enum ieee80211_bss_type bss_type;
691 	u8 *ie;
692 
693 	if (nw_type & ADHOC_NETWORK) {
694 		cap_val = WLAN_CAPABILITY_IBSS;
695 		bss_type = IEEE80211_BSS_TYPE_IBSS;
696 	} else {
697 		cap_val = WLAN_CAPABILITY_ESS;
698 		bss_type = IEEE80211_BSS_TYPE_ESS;
699 	}
700 
701 	bss = cfg80211_get_bss(ar->wiphy, chan, bssid,
702 			       vif->ssid, vif->ssid_len,
703 			       bss_type, IEEE80211_PRIVACY_ANY);
704 	if (bss == NULL) {
705 		/*
706 		 * Since cfg80211 may not yet know about the BSS,
707 		 * generate a partial entry until the first BSS info
708 		 * event becomes available.
709 		 *
710 		 * Prepend SSID element since it is not included in the Beacon
711 		 * IEs from the target.
712 		 */
713 		ie = kmalloc(2 + vif->ssid_len + beacon_ie_len, GFP_KERNEL);
714 		if (ie == NULL)
715 			return NULL;
716 		ie[0] = WLAN_EID_SSID;
717 		ie[1] = vif->ssid_len;
718 		memcpy(ie + 2, vif->ssid, vif->ssid_len);
719 		memcpy(ie + 2 + vif->ssid_len, beacon_ie, beacon_ie_len);
720 		bss = cfg80211_inform_bss(ar->wiphy, chan,
721 					  CFG80211_BSS_FTYPE_UNKNOWN,
722 					  bssid, 0, cap_val, 100,
723 					  ie, 2 + vif->ssid_len + beacon_ie_len,
724 					  0, GFP_KERNEL);
725 		if (bss)
726 			ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
727 				   "added bss %pM to cfg80211\n", bssid);
728 		kfree(ie);
729 	} else {
730 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "cfg80211 already has a bss\n");
731 	}
732 
733 	return bss;
734 }
735 
736 void ath6kl_cfg80211_connect_event(struct ath6kl_vif *vif, u16 channel,
737 				   u8 *bssid, u16 listen_intvl,
738 				   u16 beacon_intvl,
739 				   enum network_type nw_type,
740 				   u8 beacon_ie_len, u8 assoc_req_len,
741 				   u8 assoc_resp_len, u8 *assoc_info)
742 {
743 	struct ieee80211_channel *chan;
744 	struct ath6kl *ar = vif->ar;
745 	struct cfg80211_bss *bss;
746 
747 	/* capinfo + listen interval */
748 	u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16);
749 
750 	/* capinfo + status code +  associd */
751 	u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16);
752 
753 	u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset;
754 	u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len +
755 	    assoc_resp_ie_offset;
756 
757 	assoc_req_len -= assoc_req_ie_offset;
758 	assoc_resp_len -= assoc_resp_ie_offset;
759 
760 	/*
761 	 * Store Beacon interval here; DTIM period will be available only once
762 	 * a Beacon frame from the AP is seen.
763 	 */
764 	vif->assoc_bss_beacon_int = beacon_intvl;
765 	clear_bit(DTIM_PERIOD_AVAIL, &vif->flags);
766 
767 	if (nw_type & ADHOC_NETWORK) {
768 		if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) {
769 			ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
770 				   "%s: ath6k not in ibss mode\n", __func__);
771 			return;
772 		}
773 	}
774 
775 	if (nw_type & INFRA_NETWORK) {
776 		if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
777 		    vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
778 			ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
779 				   "%s: ath6k not in station mode\n", __func__);
780 			return;
781 		}
782 	}
783 
784 	chan = ieee80211_get_channel(ar->wiphy, (int) channel);
785 
786 	bss = ath6kl_add_bss_if_needed(vif, nw_type, bssid, chan,
787 				       assoc_info, beacon_ie_len);
788 	if (!bss) {
789 		ath6kl_err("could not add cfg80211 bss entry\n");
790 		return;
791 	}
792 
793 	if (nw_type & ADHOC_NETWORK) {
794 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "ad-hoc %s selected\n",
795 			   nw_type & ADHOC_CREATOR ? "creator" : "joiner");
796 		cfg80211_ibss_joined(vif->ndev, bssid, chan, GFP_KERNEL);
797 		cfg80211_put_bss(ar->wiphy, bss);
798 		return;
799 	}
800 
801 	if (vif->sme_state == SME_CONNECTING) {
802 		/* inform connect result to cfg80211 */
803 		vif->sme_state = SME_CONNECTED;
804 		cfg80211_connect_result(vif->ndev, bssid,
805 					assoc_req_ie, assoc_req_len,
806 					assoc_resp_ie, assoc_resp_len,
807 					WLAN_STATUS_SUCCESS, GFP_KERNEL);
808 		cfg80211_put_bss(ar->wiphy, bss);
809 	} else if (vif->sme_state == SME_CONNECTED) {
810 		/* inform roam event to cfg80211 */
811 		cfg80211_roamed_bss(vif->ndev, bss, assoc_req_ie, assoc_req_len,
812 				    assoc_resp_ie, assoc_resp_len, GFP_KERNEL);
813 	}
814 }
815 
816 static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy,
817 				      struct net_device *dev, u16 reason_code)
818 {
819 	struct ath6kl *ar = ath6kl_priv(dev);
820 	struct ath6kl_vif *vif = netdev_priv(dev);
821 
822 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__,
823 		   reason_code);
824 
825 	ath6kl_cfg80211_sscan_disable(vif);
826 
827 	if (!ath6kl_cfg80211_ready(vif))
828 		return -EIO;
829 
830 	if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
831 		ath6kl_err("busy, destroy in progress\n");
832 		return -EBUSY;
833 	}
834 
835 	if (down_interruptible(&ar->sem)) {
836 		ath6kl_err("busy, couldn't get access\n");
837 		return -ERESTARTSYS;
838 	}
839 
840 	vif->reconnect_flag = 0;
841 	ath6kl_disconnect(vif);
842 	memset(vif->ssid, 0, sizeof(vif->ssid));
843 	vif->ssid_len = 0;
844 
845 	if (!test_bit(SKIP_SCAN, &ar->flag))
846 		memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
847 
848 	up(&ar->sem);
849 
850 	vif->sme_state = SME_DISCONNECTED;
851 
852 	return 0;
853 }
854 
855 void ath6kl_cfg80211_disconnect_event(struct ath6kl_vif *vif, u8 reason,
856 				      u8 *bssid, u8 assoc_resp_len,
857 				      u8 *assoc_info, u16 proto_reason)
858 {
859 	struct ath6kl *ar = vif->ar;
860 
861 	if (vif->scan_req) {
862 		cfg80211_scan_done(vif->scan_req, true);
863 		vif->scan_req = NULL;
864 	}
865 
866 	if (vif->nw_type & ADHOC_NETWORK) {
867 		if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC)
868 			ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
869 				   "%s: ath6k not in ibss mode\n", __func__);
870 		return;
871 	}
872 
873 	if (vif->nw_type & INFRA_NETWORK) {
874 		if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
875 		    vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
876 			ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
877 				   "%s: ath6k not in station mode\n", __func__);
878 			return;
879 		}
880 	}
881 
882 	clear_bit(CONNECT_PEND, &vif->flags);
883 
884 	if (vif->sme_state == SME_CONNECTING) {
885 		cfg80211_connect_result(vif->ndev,
886 					bssid, NULL, 0,
887 					NULL, 0,
888 					WLAN_STATUS_UNSPECIFIED_FAILURE,
889 					GFP_KERNEL);
890 	} else if (vif->sme_state == SME_CONNECTED) {
891 		cfg80211_disconnected(vif->ndev, proto_reason,
892 				      NULL, 0, false, GFP_KERNEL);
893 	}
894 
895 	vif->sme_state = SME_DISCONNECTED;
896 
897 	/*
898 	 * Send a disconnect command to target when a disconnect event is
899 	 * received with reason code other than 3 (DISCONNECT_CMD - disconnect
900 	 * request from host) to make the firmware stop trying to connect even
901 	 * after giving disconnect event. There will be one more disconnect
902 	 * event for this disconnect command with reason code DISCONNECT_CMD
903 	 * which won't be notified to cfg80211.
904 	 */
905 	if (reason != DISCONNECT_CMD)
906 		ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
907 }
908 
909 static int ath6kl_set_probed_ssids(struct ath6kl *ar,
910 				   struct ath6kl_vif *vif,
911 				   struct cfg80211_ssid *ssids, int n_ssids,
912 				   struct cfg80211_match_set *match_set,
913 				   int n_match_ssid)
914 {
915 	u8 i, j, index_to_add, ssid_found = false;
916 	struct ath6kl_cfg80211_match_probe_ssid ssid_list[MAX_PROBED_SSIDS];
917 
918 	memset(ssid_list, 0, sizeof(ssid_list));
919 
920 	if (n_ssids > MAX_PROBED_SSIDS ||
921 	    n_match_ssid > MAX_PROBED_SSIDS)
922 		return -EINVAL;
923 
924 	for (i = 0; i < n_ssids; i++) {
925 		memcpy(ssid_list[i].ssid.ssid,
926 		       ssids[i].ssid,
927 		       ssids[i].ssid_len);
928 		ssid_list[i].ssid.ssid_len = ssids[i].ssid_len;
929 
930 		if (ssids[i].ssid_len)
931 			ssid_list[i].flag = SPECIFIC_SSID_FLAG;
932 		else
933 			ssid_list[i].flag = ANY_SSID_FLAG;
934 
935 		if (n_match_ssid == 0)
936 			ssid_list[i].flag |= MATCH_SSID_FLAG;
937 	}
938 
939 	index_to_add = i;
940 
941 	for (i = 0; i < n_match_ssid; i++) {
942 		ssid_found = false;
943 
944 		for (j = 0; j < n_ssids; j++) {
945 			if ((match_set[i].ssid.ssid_len ==
946 			     ssid_list[j].ssid.ssid_len) &&
947 			    (!memcmp(ssid_list[j].ssid.ssid,
948 				     match_set[i].ssid.ssid,
949 				     match_set[i].ssid.ssid_len))) {
950 				ssid_list[j].flag |= MATCH_SSID_FLAG;
951 				ssid_found = true;
952 				break;
953 			}
954 		}
955 
956 		if (ssid_found)
957 			continue;
958 
959 		if (index_to_add >= MAX_PROBED_SSIDS)
960 			continue;
961 
962 		ssid_list[index_to_add].ssid.ssid_len =
963 			match_set[i].ssid.ssid_len;
964 		memcpy(ssid_list[index_to_add].ssid.ssid,
965 		       match_set[i].ssid.ssid,
966 		       match_set[i].ssid.ssid_len);
967 		ssid_list[index_to_add].flag |= MATCH_SSID_FLAG;
968 		index_to_add++;
969 	}
970 
971 	for (i = 0; i < index_to_add; i++) {
972 		ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, i,
973 					  ssid_list[i].flag,
974 					  ssid_list[i].ssid.ssid_len,
975 					  ssid_list[i].ssid.ssid);
976 	}
977 
978 	/* Make sure no old entries are left behind */
979 	for (i = index_to_add; i < MAX_PROBED_SSIDS; i++) {
980 		ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx, i,
981 					  DISABLE_SSID_FLAG, 0, NULL);
982 	}
983 
984 	return 0;
985 }
986 
987 static int ath6kl_cfg80211_scan(struct wiphy *wiphy,
988 				struct cfg80211_scan_request *request)
989 {
990 	struct ath6kl_vif *vif = ath6kl_vif_from_wdev(request->wdev);
991 	struct ath6kl *ar = ath6kl_priv(vif->ndev);
992 	s8 n_channels = 0;
993 	u16 *channels = NULL;
994 	int ret = 0;
995 	u32 force_fg_scan = 0;
996 
997 	if (!ath6kl_cfg80211_ready(vif))
998 		return -EIO;
999 
1000 	ath6kl_cfg80211_sscan_disable(vif);
1001 
1002 	if (!ar->usr_bss_filter) {
1003 		clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
1004 		ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
1005 					       ALL_BSS_FILTER, 0);
1006 		if (ret) {
1007 			ath6kl_err("couldn't set bss filtering\n");
1008 			return ret;
1009 		}
1010 	}
1011 
1012 	ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
1013 				      request->n_ssids, NULL, 0);
1014 	if (ret < 0)
1015 		return ret;
1016 
1017 	/* this also clears IE in fw if it's not set */
1018 	ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
1019 				       WMI_FRAME_PROBE_REQ,
1020 				       request->ie, request->ie_len);
1021 	if (ret) {
1022 		ath6kl_err("failed to set Probe Request appie for scan\n");
1023 		return ret;
1024 	}
1025 
1026 	/*
1027 	 * Scan only the requested channels if the request specifies a set of
1028 	 * channels. If the list is longer than the target supports, do not
1029 	 * configure the list and instead, scan all available channels.
1030 	 */
1031 	if (request->n_channels > 0 &&
1032 	    request->n_channels <= WMI_MAX_CHANNELS) {
1033 		u8 i;
1034 
1035 		n_channels = request->n_channels;
1036 
1037 		channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL);
1038 		if (channels == NULL) {
1039 			ath6kl_warn("failed to set scan channels, scan all channels");
1040 			n_channels = 0;
1041 		}
1042 
1043 		for (i = 0; i < n_channels; i++)
1044 			channels[i] = request->channels[i]->center_freq;
1045 	}
1046 
1047 	if (test_bit(CONNECTED, &vif->flags))
1048 		force_fg_scan = 1;
1049 
1050 	vif->scan_req = request;
1051 
1052 	ret = ath6kl_wmi_beginscan_cmd(ar->wmi, vif->fw_vif_idx,
1053 				       WMI_LONG_SCAN, force_fg_scan,
1054 				       false, 0,
1055 				       ATH6KL_FG_SCAN_INTERVAL,
1056 				       n_channels, channels,
1057 				       request->no_cck,
1058 				       request->rates);
1059 	if (ret) {
1060 		ath6kl_err("failed to start scan: %d\n", ret);
1061 		vif->scan_req = NULL;
1062 	}
1063 
1064 	kfree(channels);
1065 
1066 	return ret;
1067 }
1068 
1069 void ath6kl_cfg80211_scan_complete_event(struct ath6kl_vif *vif, bool aborted)
1070 {
1071 	struct ath6kl *ar = vif->ar;
1072 	int i;
1073 
1074 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status%s\n", __func__,
1075 		   aborted ? " aborted" : "");
1076 
1077 	if (!vif->scan_req)
1078 		return;
1079 
1080 	if (aborted)
1081 		goto out;
1082 
1083 	if (vif->scan_req->n_ssids && vif->scan_req->ssids[0].ssid_len) {
1084 		for (i = 0; i < vif->scan_req->n_ssids; i++) {
1085 			ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx,
1086 						  i + 1, DISABLE_SSID_FLAG,
1087 						  0, NULL);
1088 		}
1089 	}
1090 
1091 out:
1092 	cfg80211_scan_done(vif->scan_req, aborted);
1093 	vif->scan_req = NULL;
1094 }
1095 
1096 void ath6kl_cfg80211_ch_switch_notify(struct ath6kl_vif *vif, int freq,
1097 				      enum wmi_phy_mode mode)
1098 {
1099 	struct cfg80211_chan_def chandef;
1100 
1101 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1102 		   "channel switch notify nw_type %d freq %d mode %d\n",
1103 		   vif->nw_type, freq, mode);
1104 
1105 	cfg80211_chandef_create(&chandef,
1106 				ieee80211_get_channel(vif->ar->wiphy, freq),
1107 				(mode == WMI_11G_HT20) ?
1108 					NL80211_CHAN_HT20 : NL80211_CHAN_NO_HT);
1109 
1110 	mutex_lock(&vif->wdev.mtx);
1111 	cfg80211_ch_switch_notify(vif->ndev, &chandef);
1112 	mutex_unlock(&vif->wdev.mtx);
1113 }
1114 
1115 static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
1116 				   u8 key_index, bool pairwise,
1117 				   const u8 *mac_addr,
1118 				   struct key_params *params)
1119 {
1120 	struct ath6kl *ar = ath6kl_priv(ndev);
1121 	struct ath6kl_vif *vif = netdev_priv(ndev);
1122 	struct ath6kl_key *key = NULL;
1123 	int seq_len;
1124 	u8 key_usage;
1125 	u8 key_type;
1126 
1127 	if (!ath6kl_cfg80211_ready(vif))
1128 		return -EIO;
1129 
1130 	if (params->cipher == CCKM_KRK_CIPHER_SUITE) {
1131 		if (params->key_len != WMI_KRK_LEN)
1132 			return -EINVAL;
1133 		return ath6kl_wmi_add_krk_cmd(ar->wmi, vif->fw_vif_idx,
1134 					      params->key);
1135 	}
1136 
1137 	if (key_index > WMI_MAX_KEY_INDEX) {
1138 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1139 			   "%s: key index %d out of bounds\n", __func__,
1140 			   key_index);
1141 		return -ENOENT;
1142 	}
1143 
1144 	key = &vif->keys[key_index];
1145 	memset(key, 0, sizeof(struct ath6kl_key));
1146 
1147 	if (pairwise)
1148 		key_usage = PAIRWISE_USAGE;
1149 	else
1150 		key_usage = GROUP_USAGE;
1151 
1152 	seq_len = params->seq_len;
1153 	if (params->cipher == WLAN_CIPHER_SUITE_SMS4 &&
1154 	    seq_len > ATH6KL_KEY_SEQ_LEN) {
1155 		/* Only first half of the WPI PN is configured */
1156 		seq_len = ATH6KL_KEY_SEQ_LEN;
1157 	}
1158 	if (params->key_len > WLAN_MAX_KEY_LEN ||
1159 	    seq_len > sizeof(key->seq))
1160 		return -EINVAL;
1161 
1162 	key->key_len = params->key_len;
1163 	memcpy(key->key, params->key, key->key_len);
1164 	key->seq_len = seq_len;
1165 	memcpy(key->seq, params->seq, key->seq_len);
1166 	key->cipher = params->cipher;
1167 
1168 	switch (key->cipher) {
1169 	case WLAN_CIPHER_SUITE_WEP40:
1170 	case WLAN_CIPHER_SUITE_WEP104:
1171 		key_type = WEP_CRYPT;
1172 		break;
1173 
1174 	case WLAN_CIPHER_SUITE_TKIP:
1175 		key_type = TKIP_CRYPT;
1176 		break;
1177 
1178 	case WLAN_CIPHER_SUITE_CCMP:
1179 		key_type = AES_CRYPT;
1180 		break;
1181 	case WLAN_CIPHER_SUITE_SMS4:
1182 		key_type = WAPI_CRYPT;
1183 		break;
1184 
1185 	default:
1186 		return -ENOTSUPP;
1187 	}
1188 
1189 	if (((vif->auth_mode == WPA_PSK_AUTH) ||
1190 	     (vif->auth_mode == WPA2_PSK_AUTH)) &&
1191 	    (key_usage & GROUP_USAGE))
1192 		del_timer(&vif->disconnect_timer);
1193 
1194 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1195 		   "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n",
1196 		   __func__, key_index, key->key_len, key_type,
1197 		   key_usage, key->seq_len);
1198 
1199 	if (vif->nw_type == AP_NETWORK && !pairwise &&
1200 	    (key_type == TKIP_CRYPT || key_type == AES_CRYPT ||
1201 	     key_type == WAPI_CRYPT)) {
1202 		ar->ap_mode_bkey.valid = true;
1203 		ar->ap_mode_bkey.key_index = key_index;
1204 		ar->ap_mode_bkey.key_type = key_type;
1205 		ar->ap_mode_bkey.key_len = key->key_len;
1206 		memcpy(ar->ap_mode_bkey.key, key->key, key->key_len);
1207 		if (!test_bit(CONNECTED, &vif->flags)) {
1208 			ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1209 				   "Delay initial group key configuration until AP mode has been started\n");
1210 			/*
1211 			 * The key will be set in ath6kl_connect_ap_mode() once
1212 			 * the connected event is received from the target.
1213 			 */
1214 			return 0;
1215 		}
1216 	}
1217 
1218 	if (vif->next_mode == AP_NETWORK && key_type == WEP_CRYPT &&
1219 	    !test_bit(CONNECTED, &vif->flags)) {
1220 		/*
1221 		 * Store the key locally so that it can be re-configured after
1222 		 * the AP mode has properly started
1223 		 * (ath6kl_install_statioc_wep_keys).
1224 		 */
1225 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1226 			   "Delay WEP key configuration until AP mode has been started\n");
1227 		vif->wep_key_list[key_index].key_len = key->key_len;
1228 		memcpy(vif->wep_key_list[key_index].key, key->key,
1229 		       key->key_len);
1230 		return 0;
1231 	}
1232 
1233 	return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, key_index,
1234 				     key_type, key_usage, key->key_len,
1235 				     key->seq, key->seq_len, key->key,
1236 				     KEY_OP_INIT_VAL,
1237 				     (u8 *) mac_addr, SYNC_BOTH_WMIFLAG);
1238 }
1239 
1240 static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
1241 				   u8 key_index, bool pairwise,
1242 				   const u8 *mac_addr)
1243 {
1244 	struct ath6kl *ar = ath6kl_priv(ndev);
1245 	struct ath6kl_vif *vif = netdev_priv(ndev);
1246 
1247 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1248 
1249 	if (!ath6kl_cfg80211_ready(vif))
1250 		return -EIO;
1251 
1252 	if (key_index > WMI_MAX_KEY_INDEX) {
1253 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1254 			   "%s: key index %d out of bounds\n", __func__,
1255 			   key_index);
1256 		return -ENOENT;
1257 	}
1258 
1259 	if (!vif->keys[key_index].key_len) {
1260 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1261 			   "%s: index %d is empty\n", __func__, key_index);
1262 		return 0;
1263 	}
1264 
1265 	vif->keys[key_index].key_len = 0;
1266 
1267 	return ath6kl_wmi_deletekey_cmd(ar->wmi, vif->fw_vif_idx, key_index);
1268 }
1269 
1270 static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
1271 				   u8 key_index, bool pairwise,
1272 				   const u8 *mac_addr, void *cookie,
1273 				   void (*callback) (void *cookie,
1274 						     struct key_params *))
1275 {
1276 	struct ath6kl_vif *vif = netdev_priv(ndev);
1277 	struct ath6kl_key *key = NULL;
1278 	struct key_params params;
1279 
1280 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1281 
1282 	if (!ath6kl_cfg80211_ready(vif))
1283 		return -EIO;
1284 
1285 	if (key_index > WMI_MAX_KEY_INDEX) {
1286 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1287 			   "%s: key index %d out of bounds\n", __func__,
1288 			   key_index);
1289 		return -ENOENT;
1290 	}
1291 
1292 	key = &vif->keys[key_index];
1293 	memset(&params, 0, sizeof(params));
1294 	params.cipher = key->cipher;
1295 	params.key_len = key->key_len;
1296 	params.seq_len = key->seq_len;
1297 	params.seq = key->seq;
1298 	params.key = key->key;
1299 
1300 	callback(cookie, &params);
1301 
1302 	return key->key_len ? 0 : -ENOENT;
1303 }
1304 
1305 static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy,
1306 					   struct net_device *ndev,
1307 					   u8 key_index, bool unicast,
1308 					   bool multicast)
1309 {
1310 	struct ath6kl *ar = ath6kl_priv(ndev);
1311 	struct ath6kl_vif *vif = netdev_priv(ndev);
1312 	struct ath6kl_key *key = NULL;
1313 	u8 key_usage;
1314 	enum crypto_type key_type = NONE_CRYPT;
1315 
1316 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1317 
1318 	if (!ath6kl_cfg80211_ready(vif))
1319 		return -EIO;
1320 
1321 	if (key_index > WMI_MAX_KEY_INDEX) {
1322 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1323 			   "%s: key index %d out of bounds\n",
1324 			   __func__, key_index);
1325 		return -ENOENT;
1326 	}
1327 
1328 	if (!vif->keys[key_index].key_len) {
1329 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n",
1330 			   __func__, key_index);
1331 		return -EINVAL;
1332 	}
1333 
1334 	vif->def_txkey_index = key_index;
1335 	key = &vif->keys[vif->def_txkey_index];
1336 	key_usage = GROUP_USAGE;
1337 	if (vif->prwise_crypto == WEP_CRYPT)
1338 		key_usage |= TX_USAGE;
1339 	if (unicast)
1340 		key_type = vif->prwise_crypto;
1341 	if (multicast)
1342 		key_type = vif->grp_crypto;
1343 
1344 	if (vif->next_mode == AP_NETWORK && !test_bit(CONNECTED, &vif->flags))
1345 		return 0; /* Delay until AP mode has been started */
1346 
1347 	return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx,
1348 				     vif->def_txkey_index,
1349 				     key_type, key_usage,
1350 				     key->key_len, key->seq, key->seq_len,
1351 				     key->key,
1352 				     KEY_OP_INIT_VAL, NULL,
1353 				     SYNC_BOTH_WMIFLAG);
1354 }
1355 
1356 void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl_vif *vif, u8 keyid,
1357 				       bool ismcast)
1358 {
1359 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1360 		   "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast);
1361 
1362 	cfg80211_michael_mic_failure(vif->ndev, vif->bssid,
1363 				     (ismcast ? NL80211_KEYTYPE_GROUP :
1364 				      NL80211_KEYTYPE_PAIRWISE), keyid, NULL,
1365 				     GFP_KERNEL);
1366 }
1367 
1368 static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1369 {
1370 	struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1371 	struct ath6kl_vif *vif;
1372 	int ret;
1373 
1374 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__,
1375 		   changed);
1376 
1377 	vif = ath6kl_vif_first(ar);
1378 	if (!vif)
1379 		return -EIO;
1380 
1381 	if (!ath6kl_cfg80211_ready(vif))
1382 		return -EIO;
1383 
1384 	if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1385 		ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold);
1386 		if (ret != 0) {
1387 			ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n");
1388 			return -EIO;
1389 		}
1390 	}
1391 
1392 	return 0;
1393 }
1394 
1395 static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy,
1396 				       struct wireless_dev *wdev,
1397 				       enum nl80211_tx_power_setting type,
1398 				       int mbm)
1399 {
1400 	struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1401 	struct ath6kl_vif *vif;
1402 	int dbm = MBM_TO_DBM(mbm);
1403 
1404 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__,
1405 		   type, dbm);
1406 
1407 	vif = ath6kl_vif_first(ar);
1408 	if (!vif)
1409 		return -EIO;
1410 
1411 	if (!ath6kl_cfg80211_ready(vif))
1412 		return -EIO;
1413 
1414 	switch (type) {
1415 	case NL80211_TX_POWER_AUTOMATIC:
1416 		return 0;
1417 	case NL80211_TX_POWER_LIMITED:
1418 		ar->tx_pwr = dbm;
1419 		break;
1420 	default:
1421 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n",
1422 			   __func__, type);
1423 		return -EOPNOTSUPP;
1424 	}
1425 
1426 	ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx, dbm);
1427 
1428 	return 0;
1429 }
1430 
1431 static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy,
1432 				       struct wireless_dev *wdev,
1433 				       int *dbm)
1434 {
1435 	struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1436 	struct ath6kl_vif *vif;
1437 
1438 	vif = ath6kl_vif_first(ar);
1439 	if (!vif)
1440 		return -EIO;
1441 
1442 	if (!ath6kl_cfg80211_ready(vif))
1443 		return -EIO;
1444 
1445 	if (test_bit(CONNECTED, &vif->flags)) {
1446 		ar->tx_pwr = 0;
1447 
1448 		if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx) != 0) {
1449 			ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n");
1450 			return -EIO;
1451 		}
1452 
1453 		wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 0,
1454 						 5 * HZ);
1455 
1456 		if (signal_pending(current)) {
1457 			ath6kl_err("target did not respond\n");
1458 			return -EINTR;
1459 		}
1460 	}
1461 
1462 	*dbm = ar->tx_pwr;
1463 	return 0;
1464 }
1465 
1466 static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
1467 					  struct net_device *dev,
1468 					  bool pmgmt, int timeout)
1469 {
1470 	struct ath6kl *ar = ath6kl_priv(dev);
1471 	struct wmi_power_mode_cmd mode;
1472 	struct ath6kl_vif *vif = netdev_priv(dev);
1473 
1474 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n",
1475 		   __func__, pmgmt, timeout);
1476 
1477 	if (!ath6kl_cfg80211_ready(vif))
1478 		return -EIO;
1479 
1480 	if (pmgmt) {
1481 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__);
1482 		mode.pwr_mode = REC_POWER;
1483 	} else {
1484 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__);
1485 		mode.pwr_mode = MAX_PERF_POWER;
1486 	}
1487 
1488 	if (ath6kl_wmi_powermode_cmd(ar->wmi, vif->fw_vif_idx,
1489 				     mode.pwr_mode) != 0) {
1490 		ath6kl_err("wmi_powermode_cmd failed\n");
1491 		return -EIO;
1492 	}
1493 
1494 	return 0;
1495 }
1496 
1497 static struct wireless_dev *ath6kl_cfg80211_add_iface(struct wiphy *wiphy,
1498 						      const char *name,
1499 						      unsigned char name_assign_type,
1500 						      enum nl80211_iftype type,
1501 						      u32 *flags,
1502 						      struct vif_params *params)
1503 {
1504 	struct ath6kl *ar = wiphy_priv(wiphy);
1505 	struct wireless_dev *wdev;
1506 	u8 if_idx, nw_type;
1507 
1508 	if (ar->num_vif == ar->vif_max) {
1509 		ath6kl_err("Reached maximum number of supported vif\n");
1510 		return ERR_PTR(-EINVAL);
1511 	}
1512 
1513 	if (!ath6kl_is_valid_iftype(ar, type, &if_idx, &nw_type)) {
1514 		ath6kl_err("Not a supported interface type\n");
1515 		return ERR_PTR(-EINVAL);
1516 	}
1517 
1518 	wdev = ath6kl_interface_add(ar, name, name_assign_type, type, if_idx, nw_type);
1519 	if (!wdev)
1520 		return ERR_PTR(-ENOMEM);
1521 
1522 	ar->num_vif++;
1523 
1524 	return wdev;
1525 }
1526 
1527 static int ath6kl_cfg80211_del_iface(struct wiphy *wiphy,
1528 				     struct wireless_dev *wdev)
1529 {
1530 	struct ath6kl *ar = wiphy_priv(wiphy);
1531 	struct ath6kl_vif *vif = netdev_priv(wdev->netdev);
1532 
1533 	spin_lock_bh(&ar->list_lock);
1534 	list_del(&vif->list);
1535 	spin_unlock_bh(&ar->list_lock);
1536 
1537 	ath6kl_cfg80211_vif_stop(vif, test_bit(WMI_READY, &ar->flag));
1538 
1539 	rtnl_lock();
1540 	ath6kl_cfg80211_vif_cleanup(vif);
1541 	rtnl_unlock();
1542 
1543 	return 0;
1544 }
1545 
1546 static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy,
1547 					struct net_device *ndev,
1548 					enum nl80211_iftype type, u32 *flags,
1549 					struct vif_params *params)
1550 {
1551 	struct ath6kl_vif *vif = netdev_priv(ndev);
1552 	int i;
1553 
1554 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type);
1555 
1556 	/*
1557 	 * Don't bring up p2p on an interface which is not initialized
1558 	 * for p2p operation where fw does not have capability to switch
1559 	 * dynamically between non-p2p and p2p type interface.
1560 	 */
1561 	if (!test_bit(ATH6KL_FW_CAPABILITY_STA_P2PDEV_DUPLEX,
1562 		      vif->ar->fw_capabilities) &&
1563 	    (type == NL80211_IFTYPE_P2P_CLIENT ||
1564 	     type == NL80211_IFTYPE_P2P_GO)) {
1565 		if (vif->ar->vif_max == 1) {
1566 			if (vif->fw_vif_idx != 0)
1567 				return -EINVAL;
1568 			else
1569 				goto set_iface_type;
1570 		}
1571 
1572 		for (i = vif->ar->max_norm_iface; i < vif->ar->vif_max; i++) {
1573 			if (i == vif->fw_vif_idx)
1574 				break;
1575 		}
1576 
1577 		if (i == vif->ar->vif_max) {
1578 			ath6kl_err("Invalid interface to bring up P2P\n");
1579 			return -EINVAL;
1580 		}
1581 	}
1582 
1583 	/* need to clean up enhanced bmiss detection fw state */
1584 	ath6kl_cfg80211_sta_bmiss_enhance(vif, false);
1585 
1586 set_iface_type:
1587 	switch (type) {
1588 	case NL80211_IFTYPE_STATION:
1589 	case NL80211_IFTYPE_P2P_CLIENT:
1590 		vif->next_mode = INFRA_NETWORK;
1591 		break;
1592 	case NL80211_IFTYPE_ADHOC:
1593 		vif->next_mode = ADHOC_NETWORK;
1594 		break;
1595 	case NL80211_IFTYPE_AP:
1596 	case NL80211_IFTYPE_P2P_GO:
1597 		vif->next_mode = AP_NETWORK;
1598 		break;
1599 	default:
1600 		ath6kl_err("invalid interface type %u\n", type);
1601 		return -EOPNOTSUPP;
1602 	}
1603 
1604 	vif->wdev.iftype = type;
1605 
1606 	return 0;
1607 }
1608 
1609 static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy,
1610 				     struct net_device *dev,
1611 				     struct cfg80211_ibss_params *ibss_param)
1612 {
1613 	struct ath6kl *ar = ath6kl_priv(dev);
1614 	struct ath6kl_vif *vif = netdev_priv(dev);
1615 	int status;
1616 
1617 	if (!ath6kl_cfg80211_ready(vif))
1618 		return -EIO;
1619 
1620 	vif->ssid_len = ibss_param->ssid_len;
1621 	memcpy(vif->ssid, ibss_param->ssid, vif->ssid_len);
1622 
1623 	if (ibss_param->chandef.chan)
1624 		vif->ch_hint = ibss_param->chandef.chan->center_freq;
1625 
1626 	if (ibss_param->channel_fixed) {
1627 		/*
1628 		 * TODO: channel_fixed: The channel should be fixed, do not
1629 		 * search for IBSSs to join on other channels. Target
1630 		 * firmware does not support this feature, needs to be
1631 		 * updated.
1632 		 */
1633 		return -EOPNOTSUPP;
1634 	}
1635 
1636 	memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
1637 	if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid))
1638 		memcpy(vif->req_bssid, ibss_param->bssid,
1639 		       sizeof(vif->req_bssid));
1640 
1641 	ath6kl_set_wpa_version(vif, 0);
1642 
1643 	status = ath6kl_set_auth_type(vif, NL80211_AUTHTYPE_OPEN_SYSTEM);
1644 	if (status)
1645 		return status;
1646 
1647 	if (ibss_param->privacy) {
1648 		ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, true);
1649 		ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, false);
1650 	} else {
1651 		ath6kl_set_cipher(vif, 0, true);
1652 		ath6kl_set_cipher(vif, 0, false);
1653 	}
1654 
1655 	vif->nw_type = vif->next_mode;
1656 
1657 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1658 		   "%s: connect called with authmode %d dot11 auth %d"
1659 		   " PW crypto %d PW crypto len %d GRP crypto %d"
1660 		   " GRP crypto len %d channel hint %u\n",
1661 		   __func__,
1662 		   vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
1663 		   vif->prwise_crypto_len, vif->grp_crypto,
1664 		   vif->grp_crypto_len, vif->ch_hint);
1665 
1666 	status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
1667 					vif->dot11_auth_mode, vif->auth_mode,
1668 					vif->prwise_crypto,
1669 					vif->prwise_crypto_len,
1670 					vif->grp_crypto, vif->grp_crypto_len,
1671 					vif->ssid_len, vif->ssid,
1672 					vif->req_bssid, vif->ch_hint,
1673 					ar->connect_ctrl_flags, SUBTYPE_NONE);
1674 	set_bit(CONNECT_PEND, &vif->flags);
1675 
1676 	return 0;
1677 }
1678 
1679 static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy,
1680 				      struct net_device *dev)
1681 {
1682 	struct ath6kl_vif *vif = netdev_priv(dev);
1683 
1684 	if (!ath6kl_cfg80211_ready(vif))
1685 		return -EIO;
1686 
1687 	ath6kl_disconnect(vif);
1688 	memset(vif->ssid, 0, sizeof(vif->ssid));
1689 	vif->ssid_len = 0;
1690 
1691 	return 0;
1692 }
1693 
1694 static const u32 cipher_suites[] = {
1695 	WLAN_CIPHER_SUITE_WEP40,
1696 	WLAN_CIPHER_SUITE_WEP104,
1697 	WLAN_CIPHER_SUITE_TKIP,
1698 	WLAN_CIPHER_SUITE_CCMP,
1699 	CCKM_KRK_CIPHER_SUITE,
1700 	WLAN_CIPHER_SUITE_SMS4,
1701 };
1702 
1703 static bool is_rate_legacy(s32 rate)
1704 {
1705 	static const s32 legacy[] = { 1000, 2000, 5500, 11000,
1706 		6000, 9000, 12000, 18000, 24000,
1707 		36000, 48000, 54000
1708 	};
1709 	u8 i;
1710 
1711 	for (i = 0; i < ARRAY_SIZE(legacy); i++)
1712 		if (rate == legacy[i])
1713 			return true;
1714 
1715 	return false;
1716 }
1717 
1718 static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
1719 {
1720 	static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
1721 		52000, 58500, 65000, 72200
1722 	};
1723 	u8 i;
1724 
1725 	for (i = 0; i < ARRAY_SIZE(ht20); i++) {
1726 		if (rate == ht20[i]) {
1727 			if (i == ARRAY_SIZE(ht20) - 1)
1728 				/* last rate uses sgi */
1729 				*sgi = true;
1730 			else
1731 				*sgi = false;
1732 
1733 			*mcs = i;
1734 			return true;
1735 		}
1736 	}
1737 	return false;
1738 }
1739 
1740 static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
1741 {
1742 	static const s32 ht40[] = { 13500, 27000, 40500, 54000,
1743 		81000, 108000, 121500, 135000,
1744 		150000
1745 	};
1746 	u8 i;
1747 
1748 	for (i = 0; i < ARRAY_SIZE(ht40); i++) {
1749 		if (rate == ht40[i]) {
1750 			if (i == ARRAY_SIZE(ht40) - 1)
1751 				/* last rate uses sgi */
1752 				*sgi = true;
1753 			else
1754 				*sgi = false;
1755 
1756 			*mcs = i;
1757 			return true;
1758 		}
1759 	}
1760 
1761 	return false;
1762 }
1763 
1764 static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev,
1765 			      const u8 *mac, struct station_info *sinfo)
1766 {
1767 	struct ath6kl *ar = ath6kl_priv(dev);
1768 	struct ath6kl_vif *vif = netdev_priv(dev);
1769 	long left;
1770 	bool sgi;
1771 	s32 rate;
1772 	int ret;
1773 	u8 mcs;
1774 
1775 	if (memcmp(mac, vif->bssid, ETH_ALEN) != 0)
1776 		return -ENOENT;
1777 
1778 	if (down_interruptible(&ar->sem))
1779 		return -EBUSY;
1780 
1781 	set_bit(STATS_UPDATE_PEND, &vif->flags);
1782 
1783 	ret = ath6kl_wmi_get_stats_cmd(ar->wmi, vif->fw_vif_idx);
1784 
1785 	if (ret != 0) {
1786 		up(&ar->sem);
1787 		return -EIO;
1788 	}
1789 
1790 	left = wait_event_interruptible_timeout(ar->event_wq,
1791 						!test_bit(STATS_UPDATE_PEND,
1792 							  &vif->flags),
1793 						WMI_TIMEOUT);
1794 
1795 	up(&ar->sem);
1796 
1797 	if (left == 0)
1798 		return -ETIMEDOUT;
1799 	else if (left < 0)
1800 		return left;
1801 
1802 	if (vif->target_stats.rx_byte) {
1803 		sinfo->rx_bytes = vif->target_stats.rx_byte;
1804 		sinfo->filled |= BIT(NL80211_STA_INFO_RX_BYTES64);
1805 		sinfo->rx_packets = vif->target_stats.rx_pkt;
1806 		sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS);
1807 	}
1808 
1809 	if (vif->target_stats.tx_byte) {
1810 		sinfo->tx_bytes = vif->target_stats.tx_byte;
1811 		sinfo->filled |= BIT(NL80211_STA_INFO_TX_BYTES64);
1812 		sinfo->tx_packets = vif->target_stats.tx_pkt;
1813 		sinfo->filled |= BIT(NL80211_STA_INFO_TX_PACKETS);
1814 	}
1815 
1816 	sinfo->signal = vif->target_stats.cs_rssi;
1817 	sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
1818 
1819 	rate = vif->target_stats.tx_ucast_rate;
1820 
1821 	if (is_rate_legacy(rate)) {
1822 		sinfo->txrate.legacy = rate / 100;
1823 	} else if (is_rate_ht20(rate, &mcs, &sgi)) {
1824 		if (sgi) {
1825 			sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1826 			sinfo->txrate.mcs = mcs - 1;
1827 		} else {
1828 			sinfo->txrate.mcs = mcs;
1829 		}
1830 
1831 		sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1832 		sinfo->txrate.bw = RATE_INFO_BW_20;
1833 	} else if (is_rate_ht40(rate, &mcs, &sgi)) {
1834 		if (sgi) {
1835 			sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1836 			sinfo->txrate.mcs = mcs - 1;
1837 		} else {
1838 			sinfo->txrate.mcs = mcs;
1839 		}
1840 
1841 		sinfo->txrate.bw = RATE_INFO_BW_40;
1842 		sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1843 	} else {
1844 		ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1845 			   "invalid rate from stats: %d\n", rate);
1846 		ath6kl_debug_war(ar, ATH6KL_WAR_INVALID_RATE);
1847 		return 0;
1848 	}
1849 
1850 	sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
1851 
1852 	if (test_bit(CONNECTED, &vif->flags) &&
1853 	    test_bit(DTIM_PERIOD_AVAIL, &vif->flags) &&
1854 	    vif->nw_type == INFRA_NETWORK) {
1855 		sinfo->filled |= BIT(NL80211_STA_INFO_BSS_PARAM);
1856 		sinfo->bss_param.flags = 0;
1857 		sinfo->bss_param.dtim_period = vif->assoc_bss_dtim_period;
1858 		sinfo->bss_param.beacon_interval = vif->assoc_bss_beacon_int;
1859 	}
1860 
1861 	return 0;
1862 }
1863 
1864 static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1865 			    struct cfg80211_pmksa *pmksa)
1866 {
1867 	struct ath6kl *ar = ath6kl_priv(netdev);
1868 	struct ath6kl_vif *vif = netdev_priv(netdev);
1869 
1870 	return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1871 				       pmksa->pmkid, true);
1872 }
1873 
1874 static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1875 			    struct cfg80211_pmksa *pmksa)
1876 {
1877 	struct ath6kl *ar = ath6kl_priv(netdev);
1878 	struct ath6kl_vif *vif = netdev_priv(netdev);
1879 
1880 	return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1881 				       pmksa->pmkid, false);
1882 }
1883 
1884 static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1885 {
1886 	struct ath6kl *ar = ath6kl_priv(netdev);
1887 	struct ath6kl_vif *vif = netdev_priv(netdev);
1888 
1889 	if (test_bit(CONNECTED, &vif->flags))
1890 		return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx,
1891 					       vif->bssid, NULL, false);
1892 	return 0;
1893 }
1894 
1895 static int ath6kl_wow_usr(struct ath6kl *ar, struct ath6kl_vif *vif,
1896 			  struct cfg80211_wowlan *wow, u32 *filter)
1897 {
1898 	int ret, pos;
1899 	u8 mask[WOW_PATTERN_SIZE];
1900 	u16 i;
1901 
1902 	/* Configure the patterns that we received from the user. */
1903 	for (i = 0; i < wow->n_patterns; i++) {
1904 		/*
1905 		 * Convert given nl80211 specific mask value to equivalent
1906 		 * driver specific mask value and send it to the chip along
1907 		 * with patterns. For example, If the mask value defined in
1908 		 * struct cfg80211_wowlan is 0xA (equivalent binary is 1010),
1909 		 * then equivalent driver specific mask value is
1910 		 * "0xFF 0x00 0xFF 0x00".
1911 		 */
1912 		memset(&mask, 0, sizeof(mask));
1913 		for (pos = 0; pos < wow->patterns[i].pattern_len; pos++) {
1914 			if (wow->patterns[i].mask[pos / 8] & (0x1 << (pos % 8)))
1915 				mask[pos] = 0xFF;
1916 		}
1917 		/*
1918 		 * Note: Pattern's offset is not passed as part of wowlan
1919 		 * parameter from CFG layer. So it's always passed as ZERO
1920 		 * to the firmware. It means, given WOW patterns are always
1921 		 * matched from the first byte of received pkt in the firmware.
1922 		 */
1923 		ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1924 				vif->fw_vif_idx, WOW_LIST_ID,
1925 				wow->patterns[i].pattern_len,
1926 				0 /* pattern offset */,
1927 				wow->patterns[i].pattern, mask);
1928 		if (ret)
1929 			return ret;
1930 	}
1931 
1932 	if (wow->disconnect)
1933 		*filter |= WOW_FILTER_OPTION_NWK_DISASSOC;
1934 
1935 	if (wow->magic_pkt)
1936 		*filter |= WOW_FILTER_OPTION_MAGIC_PACKET;
1937 
1938 	if (wow->gtk_rekey_failure)
1939 		*filter |= WOW_FILTER_OPTION_GTK_ERROR;
1940 
1941 	if (wow->eap_identity_req)
1942 		*filter |= WOW_FILTER_OPTION_EAP_REQ;
1943 
1944 	if (wow->four_way_handshake)
1945 		*filter |= WOW_FILTER_OPTION_8021X_4WAYHS;
1946 
1947 	return 0;
1948 }
1949 
1950 static int ath6kl_wow_ap(struct ath6kl *ar, struct ath6kl_vif *vif)
1951 {
1952 	static const u8 unicst_pattern[] = { 0x00, 0x00, 0x00,
1953 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1954 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1955 		0x00, 0x08 };
1956 	static const u8 unicst_mask[] = { 0x01, 0x00, 0x00,
1957 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1958 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1959 		0x00, 0x7f };
1960 	u8 unicst_offset = 0;
1961 	static const u8 arp_pattern[] = { 0x08, 0x06 };
1962 	static const u8 arp_mask[] = { 0xff, 0xff };
1963 	u8 arp_offset = 20;
1964 	static const u8 discvr_pattern[] = { 0xe0, 0x00, 0x00, 0xf8 };
1965 	static const u8 discvr_mask[] = { 0xf0, 0x00, 0x00, 0xf8 };
1966 	u8 discvr_offset = 38;
1967 	static const u8 dhcp_pattern[] = { 0xff, 0xff, 0xff, 0xff,
1968 		0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1969 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
1970 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1971 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1972 		0x00, 0x00, 0x00, 0x00, 0x00, 0x43 /* port 67 */ };
1973 	static const u8 dhcp_mask[] = { 0xff, 0xff, 0xff, 0xff,
1974 		0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1975 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
1976 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1977 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1978 		0x00, 0x00, 0x00, 0x00, 0xff, 0xff /* port 67 */ };
1979 	u8 dhcp_offset = 0;
1980 	int ret;
1981 
1982 	/* Setup unicast IP, EAPOL-like and ARP pkt pattern */
1983 	ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1984 			vif->fw_vif_idx, WOW_LIST_ID,
1985 			sizeof(unicst_pattern), unicst_offset,
1986 			unicst_pattern, unicst_mask);
1987 	if (ret) {
1988 		ath6kl_err("failed to add WOW unicast IP pattern\n");
1989 		return ret;
1990 	}
1991 
1992 	/* Setup all ARP pkt pattern */
1993 	ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1994 			vif->fw_vif_idx, WOW_LIST_ID,
1995 			sizeof(arp_pattern), arp_offset,
1996 			arp_pattern, arp_mask);
1997 	if (ret) {
1998 		ath6kl_err("failed to add WOW ARP pattern\n");
1999 		return ret;
2000 	}
2001 
2002 	/*
2003 	 * Setup multicast pattern for mDNS 224.0.0.251,
2004 	 * SSDP 239.255.255.250 and LLMNR  224.0.0.252
2005 	 */
2006 	ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2007 			vif->fw_vif_idx, WOW_LIST_ID,
2008 			sizeof(discvr_pattern), discvr_offset,
2009 			discvr_pattern, discvr_mask);
2010 	if (ret) {
2011 		ath6kl_err("failed to add WOW mDNS/SSDP/LLMNR pattern\n");
2012 		return ret;
2013 	}
2014 
2015 	/* Setup all DHCP broadcast pkt pattern */
2016 	ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2017 			vif->fw_vif_idx, WOW_LIST_ID,
2018 			sizeof(dhcp_pattern), dhcp_offset,
2019 			dhcp_pattern, dhcp_mask);
2020 	if (ret) {
2021 		ath6kl_err("failed to add WOW DHCP broadcast pattern\n");
2022 		return ret;
2023 	}
2024 
2025 	return 0;
2026 }
2027 
2028 static int ath6kl_wow_sta(struct ath6kl *ar, struct ath6kl_vif *vif)
2029 {
2030 	struct net_device *ndev = vif->ndev;
2031 	static const u8 discvr_pattern[] = { 0xe0, 0x00, 0x00, 0xf8 };
2032 	static const u8 discvr_mask[] = { 0xf0, 0x00, 0x00, 0xf8 };
2033 	u8 discvr_offset = 38;
2034 	u8 mac_mask[ETH_ALEN];
2035 	int ret;
2036 
2037 	/* Setup unicast pkt pattern */
2038 	eth_broadcast_addr(mac_mask);
2039 	ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2040 				vif->fw_vif_idx, WOW_LIST_ID,
2041 				ETH_ALEN, 0, ndev->dev_addr,
2042 				mac_mask);
2043 	if (ret) {
2044 		ath6kl_err("failed to add WOW unicast pattern\n");
2045 		return ret;
2046 	}
2047 
2048 	/*
2049 	 * Setup multicast pattern for mDNS 224.0.0.251,
2050 	 * SSDP 239.255.255.250 and LLMNR 224.0.0.252
2051 	 */
2052 	if ((ndev->flags & IFF_ALLMULTI) ||
2053 	    (ndev->flags & IFF_MULTICAST && netdev_mc_count(ndev) > 0)) {
2054 		ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
2055 				vif->fw_vif_idx, WOW_LIST_ID,
2056 				sizeof(discvr_pattern), discvr_offset,
2057 				discvr_pattern, discvr_mask);
2058 		if (ret) {
2059 			ath6kl_err("failed to add WOW mDNS/SSDP/LLMNR pattern\n");
2060 			return ret;
2061 		}
2062 	}
2063 
2064 	return 0;
2065 }
2066 
2067 static int is_hsleep_mode_procsed(struct ath6kl_vif *vif)
2068 {
2069 	return test_bit(HOST_SLEEP_MODE_CMD_PROCESSED, &vif->flags);
2070 }
2071 
2072 static bool is_ctrl_ep_empty(struct ath6kl *ar)
2073 {
2074 	return !ar->tx_pending[ar->ctrl_ep];
2075 }
2076 
2077 static int ath6kl_cfg80211_host_sleep(struct ath6kl *ar, struct ath6kl_vif *vif)
2078 {
2079 	int ret, left;
2080 
2081 	clear_bit(HOST_SLEEP_MODE_CMD_PROCESSED, &vif->flags);
2082 
2083 	ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2084 						 ATH6KL_HOST_MODE_ASLEEP);
2085 	if (ret)
2086 		return ret;
2087 
2088 	left = wait_event_interruptible_timeout(ar->event_wq,
2089 						is_hsleep_mode_procsed(vif),
2090 						WMI_TIMEOUT);
2091 	if (left == 0) {
2092 		ath6kl_warn("timeout, didn't get host sleep cmd processed event\n");
2093 		ret = -ETIMEDOUT;
2094 	} else if (left < 0) {
2095 		ath6kl_warn("error while waiting for host sleep cmd processed event %d\n",
2096 			    left);
2097 		ret = left;
2098 	}
2099 
2100 	if (ar->tx_pending[ar->ctrl_ep]) {
2101 		left = wait_event_interruptible_timeout(ar->event_wq,
2102 							is_ctrl_ep_empty(ar),
2103 							WMI_TIMEOUT);
2104 		if (left == 0) {
2105 			ath6kl_warn("clear wmi ctrl data timeout\n");
2106 			ret = -ETIMEDOUT;
2107 		} else if (left < 0) {
2108 			ath6kl_warn("clear wmi ctrl data failed: %d\n", left);
2109 			ret = left;
2110 		}
2111 	}
2112 
2113 	return ret;
2114 }
2115 
2116 static int ath6kl_wow_suspend_vif(struct ath6kl_vif *vif,
2117 				  struct cfg80211_wowlan *wow, u32 *filter)
2118 {
2119 	struct ath6kl *ar = vif->ar;
2120 	struct in_device *in_dev;
2121 	struct in_ifaddr *ifa;
2122 	int ret;
2123 	u16 i, bmiss_time;
2124 	__be32 ips[MAX_IP_ADDRS];
2125 	u8 index = 0;
2126 
2127 	if (!test_bit(NETDEV_MCAST_ALL_ON, &vif->flags) &&
2128 	    test_bit(ATH6KL_FW_CAPABILITY_WOW_MULTICAST_FILTER,
2129 		     ar->fw_capabilities)) {
2130 		ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi,
2131 						vif->fw_vif_idx, false);
2132 		if (ret)
2133 			return ret;
2134 	}
2135 
2136 	/* Clear existing WOW patterns */
2137 	for (i = 0; i < WOW_MAX_FILTERS_PER_LIST; i++)
2138 		ath6kl_wmi_del_wow_pattern_cmd(ar->wmi, vif->fw_vif_idx,
2139 					       WOW_LIST_ID, i);
2140 
2141 	/*
2142 	 * Skip the default WOW pattern configuration
2143 	 * if the driver receives any WOW patterns from
2144 	 * the user.
2145 	 */
2146 	if (wow)
2147 		ret = ath6kl_wow_usr(ar, vif, wow, filter);
2148 	else if (vif->nw_type == AP_NETWORK)
2149 		ret = ath6kl_wow_ap(ar, vif);
2150 	else
2151 		ret = ath6kl_wow_sta(ar, vif);
2152 
2153 	if (ret)
2154 		return ret;
2155 
2156 	netif_stop_queue(vif->ndev);
2157 
2158 	if (vif->nw_type != AP_NETWORK) {
2159 		ret = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
2160 						    ATH6KL_MAX_WOW_LISTEN_INTL,
2161 						    0);
2162 		if (ret)
2163 			return ret;
2164 
2165 		/* Set listen interval x 15 times as bmiss time */
2166 		bmiss_time = ATH6KL_MAX_WOW_LISTEN_INTL * 15;
2167 		if (bmiss_time > ATH6KL_MAX_BMISS_TIME)
2168 			bmiss_time = ATH6KL_MAX_BMISS_TIME;
2169 
2170 		ret = ath6kl_wmi_bmisstime_cmd(ar->wmi, vif->fw_vif_idx,
2171 					       bmiss_time, 0);
2172 		if (ret)
2173 			return ret;
2174 
2175 		ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2176 						0xFFFF, 0, 0xFFFF, 0, 0, 0,
2177 						0, 0, 0, 0);
2178 		if (ret)
2179 			return ret;
2180 	}
2181 
2182 	/* Setup own IP addr for ARP agent. */
2183 	in_dev = __in_dev_get_rtnl(vif->ndev);
2184 	if (!in_dev)
2185 		return 0;
2186 
2187 	ifa = in_dev->ifa_list;
2188 	memset(&ips, 0, sizeof(ips));
2189 
2190 	/* Configure IP addr only if IP address count < MAX_IP_ADDRS */
2191 	while (index < MAX_IP_ADDRS && ifa) {
2192 		ips[index] = ifa->ifa_local;
2193 		ifa = ifa->ifa_next;
2194 		index++;
2195 	}
2196 
2197 	if (ifa) {
2198 		ath6kl_err("total IP addr count is exceeding fw limit\n");
2199 		return -EINVAL;
2200 	}
2201 
2202 	ret = ath6kl_wmi_set_ip_cmd(ar->wmi, vif->fw_vif_idx, ips[0], ips[1]);
2203 	if (ret) {
2204 		ath6kl_err("fail to setup ip for arp agent\n");
2205 		return ret;
2206 	}
2207 
2208 	return ret;
2209 }
2210 
2211 static int ath6kl_wow_suspend(struct ath6kl *ar, struct cfg80211_wowlan *wow)
2212 {
2213 	struct ath6kl_vif *first_vif, *vif;
2214 	int ret = 0;
2215 	u32 filter = 0;
2216 	bool connected = false;
2217 
2218 	/* enter / leave wow suspend on first vif always */
2219 	first_vif = ath6kl_vif_first(ar);
2220 	if (WARN_ON(unlikely(!first_vif)) ||
2221 	    !ath6kl_cfg80211_ready(first_vif))
2222 		return -EIO;
2223 
2224 	if (wow && (wow->n_patterns > WOW_MAX_FILTERS_PER_LIST))
2225 		return -EINVAL;
2226 
2227 	/* install filters for each connected vif */
2228 	spin_lock_bh(&ar->list_lock);
2229 	list_for_each_entry(vif, &ar->vif_list, list) {
2230 		if (!test_bit(CONNECTED, &vif->flags) ||
2231 		    !ath6kl_cfg80211_ready(vif))
2232 			continue;
2233 		connected = true;
2234 
2235 		ret = ath6kl_wow_suspend_vif(vif, wow, &filter);
2236 		if (ret)
2237 			break;
2238 	}
2239 	spin_unlock_bh(&ar->list_lock);
2240 
2241 	if (!connected)
2242 		return -ENOTCONN;
2243 	else if (ret)
2244 		return ret;
2245 
2246 	ar->state = ATH6KL_STATE_SUSPENDING;
2247 
2248 	ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, first_vif->fw_vif_idx,
2249 					  ATH6KL_WOW_MODE_ENABLE,
2250 					  filter,
2251 					  WOW_HOST_REQ_DELAY);
2252 	if (ret)
2253 		return ret;
2254 
2255 	return ath6kl_cfg80211_host_sleep(ar, first_vif);
2256 }
2257 
2258 static int ath6kl_wow_resume_vif(struct ath6kl_vif *vif)
2259 {
2260 	struct ath6kl *ar = vif->ar;
2261 	int ret;
2262 
2263 	if (vif->nw_type != AP_NETWORK) {
2264 		ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2265 						0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
2266 		if (ret)
2267 			return ret;
2268 
2269 		ret = ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
2270 						    vif->listen_intvl_t, 0);
2271 		if (ret)
2272 			return ret;
2273 
2274 		ret = ath6kl_wmi_bmisstime_cmd(ar->wmi, vif->fw_vif_idx,
2275 					       vif->bmiss_time_t, 0);
2276 		if (ret)
2277 			return ret;
2278 	}
2279 
2280 	if (!test_bit(NETDEV_MCAST_ALL_OFF, &vif->flags) &&
2281 	    test_bit(ATH6KL_FW_CAPABILITY_WOW_MULTICAST_FILTER,
2282 		     ar->fw_capabilities)) {
2283 		ret = ath6kl_wmi_mcast_filter_cmd(vif->ar->wmi,
2284 						  vif->fw_vif_idx, true);
2285 		if (ret)
2286 			return ret;
2287 	}
2288 
2289 	netif_wake_queue(vif->ndev);
2290 
2291 	return 0;
2292 }
2293 
2294 static int ath6kl_wow_resume(struct ath6kl *ar)
2295 {
2296 	struct ath6kl_vif *vif;
2297 	int ret;
2298 
2299 	vif = ath6kl_vif_first(ar);
2300 	if (WARN_ON(unlikely(!vif)) ||
2301 	    !ath6kl_cfg80211_ready(vif))
2302 		return -EIO;
2303 
2304 	ar->state = ATH6KL_STATE_RESUMING;
2305 
2306 	ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2307 						 ATH6KL_HOST_MODE_AWAKE);
2308 	if (ret) {
2309 		ath6kl_warn("Failed to configure host sleep mode for wow resume: %d\n",
2310 			    ret);
2311 		goto cleanup;
2312 	}
2313 
2314 	spin_lock_bh(&ar->list_lock);
2315 	list_for_each_entry(vif, &ar->vif_list, list) {
2316 		if (!test_bit(CONNECTED, &vif->flags) ||
2317 		    !ath6kl_cfg80211_ready(vif))
2318 			continue;
2319 		ret = ath6kl_wow_resume_vif(vif);
2320 		if (ret)
2321 			break;
2322 	}
2323 	spin_unlock_bh(&ar->list_lock);
2324 
2325 	if (ret)
2326 		goto cleanup;
2327 
2328 	ar->state = ATH6KL_STATE_ON;
2329 	return 0;
2330 
2331 cleanup:
2332 	ar->state = ATH6KL_STATE_WOW;
2333 	return ret;
2334 }
2335 
2336 static int ath6kl_cfg80211_deepsleep_suspend(struct ath6kl *ar)
2337 {
2338 	struct ath6kl_vif *vif;
2339 	int ret;
2340 
2341 	vif = ath6kl_vif_first(ar);
2342 	if (!vif)
2343 		return -EIO;
2344 
2345 	if (!test_bit(WMI_READY, &ar->flag)) {
2346 		ath6kl_err("deepsleep failed as wmi is not ready\n");
2347 		return -EIO;
2348 	}
2349 
2350 	ath6kl_cfg80211_stop_all(ar);
2351 
2352 	/* Save the current power mode before enabling power save */
2353 	ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
2354 
2355 	ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER);
2356 	if (ret)
2357 		return ret;
2358 
2359 	/* Disable WOW mode */
2360 	ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx,
2361 					  ATH6KL_WOW_MODE_DISABLE,
2362 					  0, 0);
2363 	if (ret)
2364 		return ret;
2365 
2366 	/* Flush all non control pkts in TX path */
2367 	ath6kl_tx_data_cleanup(ar);
2368 
2369 	ret = ath6kl_cfg80211_host_sleep(ar, vif);
2370 	if (ret)
2371 		return ret;
2372 
2373 	return 0;
2374 }
2375 
2376 static int ath6kl_cfg80211_deepsleep_resume(struct ath6kl *ar)
2377 {
2378 	struct ath6kl_vif *vif;
2379 	int ret;
2380 
2381 	vif = ath6kl_vif_first(ar);
2382 
2383 	if (!vif)
2384 		return -EIO;
2385 
2386 	if (ar->wmi->pwr_mode != ar->wmi->saved_pwr_mode) {
2387 		ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0,
2388 					       ar->wmi->saved_pwr_mode);
2389 		if (ret)
2390 			return ret;
2391 	}
2392 
2393 	ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2394 						 ATH6KL_HOST_MODE_AWAKE);
2395 	if (ret)
2396 		return ret;
2397 
2398 	ar->state = ATH6KL_STATE_ON;
2399 
2400 	/* Reset scan parameter to default values */
2401 	ret = ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2402 					0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
2403 	if (ret)
2404 		return ret;
2405 
2406 	return 0;
2407 }
2408 
2409 int ath6kl_cfg80211_suspend(struct ath6kl *ar,
2410 			    enum ath6kl_cfg_suspend_mode mode,
2411 			    struct cfg80211_wowlan *wow)
2412 {
2413 	struct ath6kl_vif *vif;
2414 	enum ath6kl_state prev_state;
2415 	int ret;
2416 
2417 	switch (mode) {
2418 	case ATH6KL_CFG_SUSPEND_WOW:
2419 
2420 		ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode suspend\n");
2421 
2422 		/* Flush all non control pkts in TX path */
2423 		ath6kl_tx_data_cleanup(ar);
2424 
2425 		prev_state = ar->state;
2426 
2427 		ret = ath6kl_wow_suspend(ar, wow);
2428 		if (ret) {
2429 			ar->state = prev_state;
2430 			return ret;
2431 		}
2432 
2433 		ar->state = ATH6KL_STATE_WOW;
2434 		break;
2435 
2436 	case ATH6KL_CFG_SUSPEND_DEEPSLEEP:
2437 
2438 		ath6kl_dbg(ATH6KL_DBG_SUSPEND, "deep sleep suspend\n");
2439 
2440 		ret = ath6kl_cfg80211_deepsleep_suspend(ar);
2441 		if (ret) {
2442 			ath6kl_err("deepsleep suspend failed: %d\n", ret);
2443 			return ret;
2444 		}
2445 
2446 		ar->state = ATH6KL_STATE_DEEPSLEEP;
2447 
2448 		break;
2449 
2450 	case ATH6KL_CFG_SUSPEND_CUTPOWER:
2451 
2452 		ath6kl_cfg80211_stop_all(ar);
2453 
2454 		if (ar->state == ATH6KL_STATE_OFF) {
2455 			ath6kl_dbg(ATH6KL_DBG_SUSPEND,
2456 				   "suspend hw off, no action for cutpower\n");
2457 			break;
2458 		}
2459 
2460 		ath6kl_dbg(ATH6KL_DBG_SUSPEND, "suspend cutting power\n");
2461 
2462 		ret = ath6kl_init_hw_stop(ar);
2463 		if (ret) {
2464 			ath6kl_warn("failed to stop hw during suspend: %d\n",
2465 				    ret);
2466 		}
2467 
2468 		ar->state = ATH6KL_STATE_CUTPOWER;
2469 
2470 		break;
2471 
2472 	default:
2473 		break;
2474 	}
2475 
2476 	list_for_each_entry(vif, &ar->vif_list, list)
2477 		ath6kl_cfg80211_scan_complete_event(vif, true);
2478 
2479 	return 0;
2480 }
2481 EXPORT_SYMBOL(ath6kl_cfg80211_suspend);
2482 
2483 int ath6kl_cfg80211_resume(struct ath6kl *ar)
2484 {
2485 	int ret;
2486 
2487 	switch (ar->state) {
2488 	case  ATH6KL_STATE_WOW:
2489 		ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode resume\n");
2490 
2491 		ret = ath6kl_wow_resume(ar);
2492 		if (ret) {
2493 			ath6kl_warn("wow mode resume failed: %d\n", ret);
2494 			return ret;
2495 		}
2496 
2497 		break;
2498 
2499 	case ATH6KL_STATE_DEEPSLEEP:
2500 		ath6kl_dbg(ATH6KL_DBG_SUSPEND, "deep sleep resume\n");
2501 
2502 		ret = ath6kl_cfg80211_deepsleep_resume(ar);
2503 		if (ret) {
2504 			ath6kl_warn("deep sleep resume failed: %d\n", ret);
2505 			return ret;
2506 		}
2507 		break;
2508 
2509 	case ATH6KL_STATE_CUTPOWER:
2510 		ath6kl_dbg(ATH6KL_DBG_SUSPEND, "resume restoring power\n");
2511 
2512 		ret = ath6kl_init_hw_start(ar);
2513 		if (ret) {
2514 			ath6kl_warn("Failed to boot hw in resume: %d\n", ret);
2515 			return ret;
2516 		}
2517 		break;
2518 
2519 	default:
2520 		break;
2521 	}
2522 
2523 	return 0;
2524 }
2525 EXPORT_SYMBOL(ath6kl_cfg80211_resume);
2526 
2527 #ifdef CONFIG_PM
2528 
2529 /* hif layer decides what suspend mode to use */
2530 static int __ath6kl_cfg80211_suspend(struct wiphy *wiphy,
2531 				 struct cfg80211_wowlan *wow)
2532 {
2533 	struct ath6kl *ar = wiphy_priv(wiphy);
2534 
2535 	ath6kl_recovery_suspend(ar);
2536 
2537 	return ath6kl_hif_suspend(ar, wow);
2538 }
2539 
2540 static int __ath6kl_cfg80211_resume(struct wiphy *wiphy)
2541 {
2542 	struct ath6kl *ar = wiphy_priv(wiphy);
2543 	int err;
2544 
2545 	err = ath6kl_hif_resume(ar);
2546 	if (err)
2547 		return err;
2548 
2549 	ath6kl_recovery_resume(ar);
2550 
2551 	return 0;
2552 }
2553 
2554 /*
2555  * FIXME: WOW suspend mode is selected if the host sdio controller supports
2556  * both sdio irq wake up and keep power. The target pulls sdio data line to
2557  * wake up the host when WOW pattern matches. This causes sdio irq handler
2558  * is being called in the host side which internally hits ath6kl's RX path.
2559  *
2560  * Since sdio interrupt is not disabled, RX path executes even before
2561  * the host executes the actual resume operation from PM module.
2562  *
2563  * In the current scenario, WOW resume should happen before start processing
2564  * any data from the target. So It's required to perform WOW resume in RX path.
2565  * Ideally we should perform WOW resume only in the actual platform
2566  * resume path. This area needs bit rework to avoid WOW resume in RX path.
2567  *
2568  * ath6kl_check_wow_status() is called from ath6kl_rx().
2569  */
2570 void ath6kl_check_wow_status(struct ath6kl *ar)
2571 {
2572 	if (ar->state == ATH6KL_STATE_SUSPENDING)
2573 		return;
2574 
2575 	if (ar->state == ATH6KL_STATE_WOW)
2576 		ath6kl_cfg80211_resume(ar);
2577 }
2578 
2579 #else
2580 
2581 void ath6kl_check_wow_status(struct ath6kl *ar)
2582 {
2583 }
2584 #endif
2585 
2586 static int ath6kl_set_htcap(struct ath6kl_vif *vif, enum ieee80211_band band,
2587 			    bool ht_enable)
2588 {
2589 	struct ath6kl_htcap *htcap = &vif->htcap[band];
2590 
2591 	if (htcap->ht_enable == ht_enable)
2592 		return 0;
2593 
2594 	if (ht_enable) {
2595 		/* Set default ht capabilities */
2596 		htcap->ht_enable = true;
2597 		htcap->cap_info = (band == IEEE80211_BAND_2GHZ) ?
2598 				   ath6kl_g_htcap : ath6kl_a_htcap;
2599 		htcap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K;
2600 	} else /* Disable ht */
2601 		memset(htcap, 0, sizeof(*htcap));
2602 
2603 	return ath6kl_wmi_set_htcap_cmd(vif->ar->wmi, vif->fw_vif_idx,
2604 					band, htcap);
2605 }
2606 
2607 static int ath6kl_restore_htcap(struct ath6kl_vif *vif)
2608 {
2609 	struct wiphy *wiphy = vif->ar->wiphy;
2610 	int band, ret = 0;
2611 
2612 	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2613 		if (!wiphy->bands[band])
2614 			continue;
2615 
2616 		ret = ath6kl_set_htcap(vif, band,
2617 				wiphy->bands[band]->ht_cap.ht_supported);
2618 		if (ret)
2619 			return ret;
2620 	}
2621 
2622 	return ret;
2623 }
2624 
2625 static bool ath6kl_is_p2p_ie(const u8 *pos)
2626 {
2627 	return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
2628 		pos[2] == 0x50 && pos[3] == 0x6f &&
2629 		pos[4] == 0x9a && pos[5] == 0x09;
2630 }
2631 
2632 static int ath6kl_set_ap_probe_resp_ies(struct ath6kl_vif *vif,
2633 					const u8 *ies, size_t ies_len)
2634 {
2635 	struct ath6kl *ar = vif->ar;
2636 	const u8 *pos;
2637 	u8 *buf = NULL;
2638 	size_t len = 0;
2639 	int ret;
2640 
2641 	/*
2642 	 * Filter out P2P IE(s) since they will be included depending on
2643 	 * the Probe Request frame in ath6kl_send_go_probe_resp().
2644 	 */
2645 
2646 	if (ies && ies_len) {
2647 		buf = kmalloc(ies_len, GFP_KERNEL);
2648 		if (buf == NULL)
2649 			return -ENOMEM;
2650 		pos = ies;
2651 		while (pos + 1 < ies + ies_len) {
2652 			if (pos + 2 + pos[1] > ies + ies_len)
2653 				break;
2654 			if (!ath6kl_is_p2p_ie(pos)) {
2655 				memcpy(buf + len, pos, 2 + pos[1]);
2656 				len += 2 + pos[1];
2657 			}
2658 			pos += 2 + pos[1];
2659 		}
2660 	}
2661 
2662 	ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2663 				       WMI_FRAME_PROBE_RESP, buf, len);
2664 	kfree(buf);
2665 	return ret;
2666 }
2667 
2668 static int ath6kl_set_ies(struct ath6kl_vif *vif,
2669 			  struct cfg80211_beacon_data *info)
2670 {
2671 	struct ath6kl *ar = vif->ar;
2672 	int res;
2673 
2674 	/* this also clears IE in fw if it's not set */
2675 	res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2676 				       WMI_FRAME_BEACON,
2677 				       info->beacon_ies,
2678 				       info->beacon_ies_len);
2679 	if (res)
2680 		return res;
2681 
2682 	/* this also clears IE in fw if it's not set */
2683 	res = ath6kl_set_ap_probe_resp_ies(vif, info->proberesp_ies,
2684 					   info->proberesp_ies_len);
2685 	if (res)
2686 		return res;
2687 
2688 	/* this also clears IE in fw if it's not set */
2689 	res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2690 				       WMI_FRAME_ASSOC_RESP,
2691 				       info->assocresp_ies,
2692 				       info->assocresp_ies_len);
2693 	if (res)
2694 		return res;
2695 
2696 	return 0;
2697 }
2698 
2699 static int ath6kl_get_rsn_capab(struct cfg80211_beacon_data *beacon,
2700 				u8 *rsn_capab)
2701 {
2702 	const u8 *rsn_ie;
2703 	size_t rsn_ie_len;
2704 	u16 cnt;
2705 
2706 	if (!beacon->tail)
2707 		return -EINVAL;
2708 
2709 	rsn_ie = cfg80211_find_ie(WLAN_EID_RSN, beacon->tail, beacon->tail_len);
2710 	if (!rsn_ie)
2711 		return -EINVAL;
2712 
2713 	rsn_ie_len = *(rsn_ie + 1);
2714 	/* skip element id and length */
2715 	rsn_ie += 2;
2716 
2717 	/* skip version */
2718 	if (rsn_ie_len < 2)
2719 		return -EINVAL;
2720 	rsn_ie +=  2;
2721 	rsn_ie_len -= 2;
2722 
2723 	/* skip group cipher suite */
2724 	if (rsn_ie_len < 4)
2725 		return 0;
2726 	rsn_ie +=  4;
2727 	rsn_ie_len -= 4;
2728 
2729 	/* skip pairwise cipher suite */
2730 	if (rsn_ie_len < 2)
2731 		return 0;
2732 	cnt = get_unaligned_le16(rsn_ie);
2733 	rsn_ie += (2 + cnt * 4);
2734 	rsn_ie_len -= (2 + cnt * 4);
2735 
2736 	/* skip akm suite */
2737 	if (rsn_ie_len < 2)
2738 		return 0;
2739 	cnt = get_unaligned_le16(rsn_ie);
2740 	rsn_ie += (2 + cnt * 4);
2741 	rsn_ie_len -= (2 + cnt * 4);
2742 
2743 	if (rsn_ie_len < 2)
2744 		return 0;
2745 
2746 	memcpy(rsn_capab, rsn_ie, 2);
2747 
2748 	return 0;
2749 }
2750 
2751 static int ath6kl_start_ap(struct wiphy *wiphy, struct net_device *dev,
2752 			   struct cfg80211_ap_settings *info)
2753 {
2754 	struct ath6kl *ar = ath6kl_priv(dev);
2755 	struct ath6kl_vif *vif = netdev_priv(dev);
2756 	struct ieee80211_mgmt *mgmt;
2757 	bool hidden = false;
2758 	u8 *ies;
2759 	int ies_len;
2760 	struct wmi_connect_cmd p;
2761 	int res;
2762 	int i, ret;
2763 	u16 rsn_capab = 0;
2764 	int inactivity_timeout = 0;
2765 
2766 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s:\n", __func__);
2767 
2768 	if (!ath6kl_cfg80211_ready(vif))
2769 		return -EIO;
2770 
2771 	if (vif->next_mode != AP_NETWORK)
2772 		return -EOPNOTSUPP;
2773 
2774 	res = ath6kl_set_ies(vif, &info->beacon);
2775 
2776 	ar->ap_mode_bkey.valid = false;
2777 
2778 	ret = ath6kl_wmi_ap_set_beacon_intvl_cmd(ar->wmi, vif->fw_vif_idx,
2779 						 info->beacon_interval);
2780 
2781 	if (ret)
2782 		ath6kl_warn("Failed to set beacon interval: %d\n", ret);
2783 
2784 	ret = ath6kl_wmi_ap_set_dtim_cmd(ar->wmi, vif->fw_vif_idx,
2785 					 info->dtim_period);
2786 
2787 	/* ignore error, just print a warning and continue normally */
2788 	if (ret)
2789 		ath6kl_warn("Failed to set dtim_period in beacon: %d\n", ret);
2790 
2791 	if (info->beacon.head == NULL)
2792 		return -EINVAL;
2793 	mgmt = (struct ieee80211_mgmt *) info->beacon.head;
2794 	ies = mgmt->u.beacon.variable;
2795 	if (ies > info->beacon.head + info->beacon.head_len)
2796 		return -EINVAL;
2797 	ies_len = info->beacon.head + info->beacon.head_len - ies;
2798 
2799 	if (info->ssid == NULL)
2800 		return -EINVAL;
2801 	memcpy(vif->ssid, info->ssid, info->ssid_len);
2802 	vif->ssid_len = info->ssid_len;
2803 	if (info->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE)
2804 		hidden = true;
2805 
2806 	res = ath6kl_wmi_ap_hidden_ssid(ar->wmi, vif->fw_vif_idx, hidden);
2807 	if (res)
2808 		return res;
2809 
2810 	ret = ath6kl_set_auth_type(vif, info->auth_type);
2811 	if (ret)
2812 		return ret;
2813 
2814 	memset(&p, 0, sizeof(p));
2815 
2816 	for (i = 0; i < info->crypto.n_akm_suites; i++) {
2817 		switch (info->crypto.akm_suites[i]) {
2818 		case WLAN_AKM_SUITE_8021X:
2819 			if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2820 				p.auth_mode |= WPA_AUTH;
2821 			if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2822 				p.auth_mode |= WPA2_AUTH;
2823 			break;
2824 		case WLAN_AKM_SUITE_PSK:
2825 			if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2826 				p.auth_mode |= WPA_PSK_AUTH;
2827 			if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2828 				p.auth_mode |= WPA2_PSK_AUTH;
2829 			break;
2830 		}
2831 	}
2832 	if (p.auth_mode == 0)
2833 		p.auth_mode = NONE_AUTH;
2834 	vif->auth_mode = p.auth_mode;
2835 
2836 	for (i = 0; i < info->crypto.n_ciphers_pairwise; i++) {
2837 		switch (info->crypto.ciphers_pairwise[i]) {
2838 		case WLAN_CIPHER_SUITE_WEP40:
2839 		case WLAN_CIPHER_SUITE_WEP104:
2840 			p.prwise_crypto_type |= WEP_CRYPT;
2841 			break;
2842 		case WLAN_CIPHER_SUITE_TKIP:
2843 			p.prwise_crypto_type |= TKIP_CRYPT;
2844 			break;
2845 		case WLAN_CIPHER_SUITE_CCMP:
2846 			p.prwise_crypto_type |= AES_CRYPT;
2847 			break;
2848 		case WLAN_CIPHER_SUITE_SMS4:
2849 			p.prwise_crypto_type |= WAPI_CRYPT;
2850 			break;
2851 		}
2852 	}
2853 	if (p.prwise_crypto_type == 0) {
2854 		p.prwise_crypto_type = NONE_CRYPT;
2855 		ath6kl_set_cipher(vif, 0, true);
2856 	} else if (info->crypto.n_ciphers_pairwise == 1) {
2857 		ath6kl_set_cipher(vif, info->crypto.ciphers_pairwise[0], true);
2858 	}
2859 
2860 	switch (info->crypto.cipher_group) {
2861 	case WLAN_CIPHER_SUITE_WEP40:
2862 	case WLAN_CIPHER_SUITE_WEP104:
2863 		p.grp_crypto_type = WEP_CRYPT;
2864 		break;
2865 	case WLAN_CIPHER_SUITE_TKIP:
2866 		p.grp_crypto_type = TKIP_CRYPT;
2867 		break;
2868 	case WLAN_CIPHER_SUITE_CCMP:
2869 		p.grp_crypto_type = AES_CRYPT;
2870 		break;
2871 	case WLAN_CIPHER_SUITE_SMS4:
2872 		p.grp_crypto_type = WAPI_CRYPT;
2873 		break;
2874 	default:
2875 		p.grp_crypto_type = NONE_CRYPT;
2876 		break;
2877 	}
2878 	ath6kl_set_cipher(vif, info->crypto.cipher_group, false);
2879 
2880 	p.nw_type = AP_NETWORK;
2881 	vif->nw_type = vif->next_mode;
2882 
2883 	p.ssid_len = vif->ssid_len;
2884 	memcpy(p.ssid, vif->ssid, vif->ssid_len);
2885 	p.dot11_auth_mode = vif->dot11_auth_mode;
2886 	p.ch = cpu_to_le16(info->chandef.chan->center_freq);
2887 
2888 	/* Enable uAPSD support by default */
2889 	res = ath6kl_wmi_ap_set_apsd(ar->wmi, vif->fw_vif_idx, true);
2890 	if (res < 0)
2891 		return res;
2892 
2893 	if (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
2894 		p.nw_subtype = SUBTYPE_P2PGO;
2895 	} else {
2896 		/*
2897 		 * Due to firmware limitation, it is not possible to
2898 		 * do P2P mgmt operations in AP mode
2899 		 */
2900 		p.nw_subtype = SUBTYPE_NONE;
2901 	}
2902 
2903 	if (info->inactivity_timeout) {
2904 		inactivity_timeout = info->inactivity_timeout;
2905 
2906 		if (test_bit(ATH6KL_FW_CAPABILITY_AP_INACTIVITY_MINS,
2907 			     ar->fw_capabilities))
2908 			inactivity_timeout = DIV_ROUND_UP(inactivity_timeout,
2909 							  60);
2910 
2911 		res = ath6kl_wmi_set_inact_period(ar->wmi, vif->fw_vif_idx,
2912 						  inactivity_timeout);
2913 		if (res < 0)
2914 			return res;
2915 	}
2916 
2917 	if (ath6kl_set_htcap(vif, info->chandef.chan->band,
2918 			     cfg80211_get_chandef_type(&info->chandef)
2919 					!= NL80211_CHAN_NO_HT))
2920 		return -EIO;
2921 
2922 	/*
2923 	 * Get the PTKSA replay counter in the RSN IE. Supplicant
2924 	 * will use the RSN IE in M3 message and firmware has to
2925 	 * advertise the same in beacon/probe response. Send
2926 	 * the complete RSN IE capability field to firmware
2927 	 */
2928 	if (!ath6kl_get_rsn_capab(&info->beacon, (u8 *) &rsn_capab) &&
2929 	    test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
2930 		     ar->fw_capabilities)) {
2931 		res = ath6kl_wmi_set_ie_cmd(ar->wmi, vif->fw_vif_idx,
2932 					    WLAN_EID_RSN, WMI_RSN_IE_CAPB,
2933 					    (const u8 *) &rsn_capab,
2934 					    sizeof(rsn_capab));
2935 		vif->rsn_capab = rsn_capab;
2936 		if (res < 0)
2937 			return res;
2938 	}
2939 
2940 	memcpy(&vif->profile, &p, sizeof(p));
2941 	res = ath6kl_wmi_ap_profile_commit(ar->wmi, vif->fw_vif_idx, &p);
2942 	if (res < 0)
2943 		return res;
2944 
2945 	return 0;
2946 }
2947 
2948 static int ath6kl_change_beacon(struct wiphy *wiphy, struct net_device *dev,
2949 				struct cfg80211_beacon_data *beacon)
2950 {
2951 	struct ath6kl_vif *vif = netdev_priv(dev);
2952 
2953 	if (!ath6kl_cfg80211_ready(vif))
2954 		return -EIO;
2955 
2956 	if (vif->next_mode != AP_NETWORK)
2957 		return -EOPNOTSUPP;
2958 
2959 	return ath6kl_set_ies(vif, beacon);
2960 }
2961 
2962 static int ath6kl_stop_ap(struct wiphy *wiphy, struct net_device *dev)
2963 {
2964 	struct ath6kl *ar = ath6kl_priv(dev);
2965 	struct ath6kl_vif *vif = netdev_priv(dev);
2966 
2967 	if (vif->nw_type != AP_NETWORK)
2968 		return -EOPNOTSUPP;
2969 	if (!test_bit(CONNECTED, &vif->flags))
2970 		return -ENOTCONN;
2971 
2972 	ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
2973 	clear_bit(CONNECTED, &vif->flags);
2974 
2975 	/* Restore ht setting in firmware */
2976 	return ath6kl_restore_htcap(vif);
2977 }
2978 
2979 static const u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2980 
2981 static int ath6kl_del_station(struct wiphy *wiphy, struct net_device *dev,
2982 			      struct station_del_parameters *params)
2983 {
2984 	struct ath6kl *ar = ath6kl_priv(dev);
2985 	struct ath6kl_vif *vif = netdev_priv(dev);
2986 	const u8 *addr = params->mac ? params->mac : bcast_addr;
2987 
2988 	return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx, WMI_AP_DEAUTH,
2989 				      addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
2990 }
2991 
2992 static int ath6kl_change_station(struct wiphy *wiphy, struct net_device *dev,
2993 				 const u8 *mac,
2994 				 struct station_parameters *params)
2995 {
2996 	struct ath6kl *ar = ath6kl_priv(dev);
2997 	struct ath6kl_vif *vif = netdev_priv(dev);
2998 	int err;
2999 
3000 	if (vif->nw_type != AP_NETWORK)
3001 		return -EOPNOTSUPP;
3002 
3003 	err = cfg80211_check_station_change(wiphy, params,
3004 					    CFG80211_STA_AP_MLME_CLIENT);
3005 	if (err)
3006 		return err;
3007 
3008 	if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
3009 		return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
3010 					      WMI_AP_MLME_AUTHORIZE, mac, 0);
3011 	return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
3012 				      WMI_AP_MLME_UNAUTHORIZE, mac, 0);
3013 }
3014 
3015 static int ath6kl_remain_on_channel(struct wiphy *wiphy,
3016 				    struct wireless_dev *wdev,
3017 				    struct ieee80211_channel *chan,
3018 				    unsigned int duration,
3019 				    u64 *cookie)
3020 {
3021 	struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3022 	struct ath6kl *ar = ath6kl_priv(vif->ndev);
3023 	u32 id;
3024 
3025 	/* TODO: if already pending or ongoing remain-on-channel,
3026 	 * return -EBUSY */
3027 	id = ++vif->last_roc_id;
3028 	if (id == 0) {
3029 		/* Do not use 0 as the cookie value */
3030 		id = ++vif->last_roc_id;
3031 	}
3032 	*cookie = id;
3033 
3034 	return ath6kl_wmi_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx,
3035 					     chan->center_freq, duration);
3036 }
3037 
3038 static int ath6kl_cancel_remain_on_channel(struct wiphy *wiphy,
3039 					   struct wireless_dev *wdev,
3040 					   u64 cookie)
3041 {
3042 	struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3043 	struct ath6kl *ar = ath6kl_priv(vif->ndev);
3044 
3045 	if (cookie != vif->last_roc_id)
3046 		return -ENOENT;
3047 	vif->last_cancel_roc_id = cookie;
3048 
3049 	return ath6kl_wmi_cancel_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx);
3050 }
3051 
3052 static int ath6kl_send_go_probe_resp(struct ath6kl_vif *vif,
3053 				     const u8 *buf, size_t len,
3054 				     unsigned int freq)
3055 {
3056 	struct ath6kl *ar = vif->ar;
3057 	const u8 *pos;
3058 	u8 *p2p;
3059 	int p2p_len;
3060 	int ret;
3061 	const struct ieee80211_mgmt *mgmt;
3062 
3063 	mgmt = (const struct ieee80211_mgmt *) buf;
3064 
3065 	/* Include P2P IE(s) from the frame generated in user space. */
3066 
3067 	p2p = kmalloc(len, GFP_KERNEL);
3068 	if (p2p == NULL)
3069 		return -ENOMEM;
3070 	p2p_len = 0;
3071 
3072 	pos = mgmt->u.probe_resp.variable;
3073 	while (pos + 1 < buf + len) {
3074 		if (pos + 2 + pos[1] > buf + len)
3075 			break;
3076 		if (ath6kl_is_p2p_ie(pos)) {
3077 			memcpy(p2p + p2p_len, pos, 2 + pos[1]);
3078 			p2p_len += 2 + pos[1];
3079 		}
3080 		pos += 2 + pos[1];
3081 	}
3082 
3083 	ret = ath6kl_wmi_send_probe_response_cmd(ar->wmi, vif->fw_vif_idx, freq,
3084 						 mgmt->da, p2p, p2p_len);
3085 	kfree(p2p);
3086 	return ret;
3087 }
3088 
3089 static bool ath6kl_mgmt_powersave_ap(struct ath6kl_vif *vif,
3090 				     u32 id,
3091 				     u32 freq,
3092 				     u32 wait,
3093 				     const u8 *buf,
3094 				     size_t len,
3095 				     bool *more_data,
3096 				     bool no_cck)
3097 {
3098 	struct ieee80211_mgmt *mgmt;
3099 	struct ath6kl_sta *conn;
3100 	bool is_psq_empty = false;
3101 	struct ath6kl_mgmt_buff *mgmt_buf;
3102 	size_t mgmt_buf_size;
3103 	struct ath6kl *ar = vif->ar;
3104 
3105 	mgmt = (struct ieee80211_mgmt *) buf;
3106 	if (is_multicast_ether_addr(mgmt->da))
3107 		return false;
3108 
3109 	conn = ath6kl_find_sta(vif, mgmt->da);
3110 	if (!conn)
3111 		return false;
3112 
3113 	if (conn->sta_flags & STA_PS_SLEEP) {
3114 		if (!(conn->sta_flags & STA_PS_POLLED)) {
3115 			/* Queue the frames if the STA is sleeping */
3116 			mgmt_buf_size = len + sizeof(struct ath6kl_mgmt_buff);
3117 			mgmt_buf = kmalloc(mgmt_buf_size, GFP_KERNEL);
3118 			if (!mgmt_buf)
3119 				return false;
3120 
3121 			INIT_LIST_HEAD(&mgmt_buf->list);
3122 			mgmt_buf->id = id;
3123 			mgmt_buf->freq = freq;
3124 			mgmt_buf->wait = wait;
3125 			mgmt_buf->len = len;
3126 			mgmt_buf->no_cck = no_cck;
3127 			memcpy(mgmt_buf->buf, buf, len);
3128 			spin_lock_bh(&conn->psq_lock);
3129 			is_psq_empty = skb_queue_empty(&conn->psq) &&
3130 					(conn->mgmt_psq_len == 0);
3131 			list_add_tail(&mgmt_buf->list, &conn->mgmt_psq);
3132 			conn->mgmt_psq_len++;
3133 			spin_unlock_bh(&conn->psq_lock);
3134 
3135 			/*
3136 			 * If this is the first pkt getting queued
3137 			 * for this STA, update the PVB for this
3138 			 * STA.
3139 			 */
3140 			if (is_psq_empty)
3141 				ath6kl_wmi_set_pvb_cmd(ar->wmi, vif->fw_vif_idx,
3142 						       conn->aid, 1);
3143 			return true;
3144 		}
3145 
3146 		/*
3147 		 * This tx is because of a PsPoll.
3148 		 * Determine if MoreData bit has to be set.
3149 		 */
3150 		spin_lock_bh(&conn->psq_lock);
3151 		if (!skb_queue_empty(&conn->psq) || (conn->mgmt_psq_len != 0))
3152 			*more_data = true;
3153 		spin_unlock_bh(&conn->psq_lock);
3154 	}
3155 
3156 	return false;
3157 }
3158 
3159 /* Check if SSID length is greater than DIRECT- */
3160 static bool ath6kl_is_p2p_go_ssid(const u8 *buf, size_t len)
3161 {
3162 	const struct ieee80211_mgmt *mgmt;
3163 	mgmt = (const struct ieee80211_mgmt *) buf;
3164 
3165 	/* variable[1] contains the SSID tag length */
3166 	if (buf + len >= &mgmt->u.probe_resp.variable[1] &&
3167 	    (mgmt->u.probe_resp.variable[1] > P2P_WILDCARD_SSID_LEN)) {
3168 		return true;
3169 	}
3170 
3171 	return false;
3172 }
3173 
3174 static int ath6kl_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
3175 			  struct cfg80211_mgmt_tx_params *params, u64 *cookie)
3176 {
3177 	struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3178 	struct ath6kl *ar = ath6kl_priv(vif->ndev);
3179 	struct ieee80211_channel *chan = params->chan;
3180 	const u8 *buf = params->buf;
3181 	size_t len = params->len;
3182 	unsigned int wait = params->wait;
3183 	bool no_cck = params->no_cck;
3184 	u32 id, freq;
3185 	const struct ieee80211_mgmt *mgmt;
3186 	bool more_data, queued;
3187 
3188 	/* default to the current channel, but use the one specified as argument
3189 	 * if any
3190 	 */
3191 	freq = vif->ch_hint;
3192 	if (chan)
3193 		freq = chan->center_freq;
3194 
3195 	/* never send freq zero to the firmware */
3196 	if (WARN_ON(freq == 0))
3197 		return -EINVAL;
3198 
3199 	mgmt = (const struct ieee80211_mgmt *) buf;
3200 	if (vif->nw_type == AP_NETWORK && test_bit(CONNECTED, &vif->flags) &&
3201 	    ieee80211_is_probe_resp(mgmt->frame_control) &&
3202 	    ath6kl_is_p2p_go_ssid(buf, len)) {
3203 		/*
3204 		 * Send Probe Response frame in GO mode using a separate WMI
3205 		 * command to allow the target to fill in the generic IEs.
3206 		 */
3207 		*cookie = 0; /* TX status not supported */
3208 		return ath6kl_send_go_probe_resp(vif, buf, len, freq);
3209 	}
3210 
3211 	id = vif->send_action_id++;
3212 	if (id == 0) {
3213 		/*
3214 		 * 0 is a reserved value in the WMI command and shall not be
3215 		 * used for the command.
3216 		 */
3217 		id = vif->send_action_id++;
3218 	}
3219 
3220 	*cookie = id;
3221 
3222 	/* AP mode Power saving processing */
3223 	if (vif->nw_type == AP_NETWORK) {
3224 		queued = ath6kl_mgmt_powersave_ap(vif, id, freq, wait, buf, len,
3225 						  &more_data, no_cck);
3226 		if (queued)
3227 			return 0;
3228 	}
3229 
3230 	return ath6kl_wmi_send_mgmt_cmd(ar->wmi, vif->fw_vif_idx, id, freq,
3231 					wait, buf, len, no_cck);
3232 }
3233 
3234 static void ath6kl_mgmt_frame_register(struct wiphy *wiphy,
3235 				       struct wireless_dev *wdev,
3236 				       u16 frame_type, bool reg)
3237 {
3238 	struct ath6kl_vif *vif = ath6kl_vif_from_wdev(wdev);
3239 
3240 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: frame_type=0x%x reg=%d\n",
3241 		   __func__, frame_type, reg);
3242 	if (frame_type == IEEE80211_STYPE_PROBE_REQ) {
3243 		/*
3244 		 * Note: This notification callback is not allowed to sleep, so
3245 		 * we cannot send WMI_PROBE_REQ_REPORT_CMD here. Instead, we
3246 		 * hardcode target to report Probe Request frames all the time.
3247 		 */
3248 		vif->probe_req_report = reg;
3249 	}
3250 }
3251 
3252 static int ath6kl_cfg80211_sscan_start(struct wiphy *wiphy,
3253 			struct net_device *dev,
3254 			struct cfg80211_sched_scan_request *request)
3255 {
3256 	struct ath6kl *ar = ath6kl_priv(dev);
3257 	struct ath6kl_vif *vif = netdev_priv(dev);
3258 	u16 interval;
3259 	int ret, rssi_thold;
3260 	int n_match_sets = request->n_match_sets;
3261 
3262 	/*
3263 	 * If there's a matchset w/o an SSID, then assume it's just for
3264 	 * the RSSI (nothing else is currently supported) and ignore it.
3265 	 * The device only supports a global RSSI filter that we set below.
3266 	 */
3267 	if (n_match_sets == 1 && !request->match_sets[0].ssid.ssid_len)
3268 		n_match_sets = 0;
3269 
3270 	if (ar->state != ATH6KL_STATE_ON)
3271 		return -EIO;
3272 
3273 	if (vif->sme_state != SME_DISCONNECTED)
3274 		return -EBUSY;
3275 
3276 	ath6kl_cfg80211_scan_complete_event(vif, true);
3277 
3278 	ret = ath6kl_set_probed_ssids(ar, vif, request->ssids,
3279 				      request->n_ssids,
3280 				      request->match_sets,
3281 				      n_match_sets);
3282 	if (ret < 0)
3283 		return ret;
3284 
3285 	if (!n_match_sets) {
3286 		ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
3287 					       ALL_BSS_FILTER, 0);
3288 		if (ret < 0)
3289 			return ret;
3290 	} else {
3291 		 ret = ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
3292 						MATCHED_SSID_FILTER, 0);
3293 		if (ret < 0)
3294 			return ret;
3295 	}
3296 
3297 	if (test_bit(ATH6KL_FW_CAPABILITY_RSSI_SCAN_THOLD,
3298 		     ar->fw_capabilities)) {
3299 		if (request->min_rssi_thold <= NL80211_SCAN_RSSI_THOLD_OFF)
3300 			rssi_thold = 0;
3301 		else if (request->min_rssi_thold < -127)
3302 			rssi_thold = -127;
3303 		else
3304 			rssi_thold = request->min_rssi_thold;
3305 
3306 		ret = ath6kl_wmi_set_rssi_filter_cmd(ar->wmi, vif->fw_vif_idx,
3307 						     rssi_thold);
3308 		if (ret) {
3309 			ath6kl_err("failed to set RSSI threshold for scan\n");
3310 			return ret;
3311 		}
3312 	}
3313 
3314 	/* fw uses seconds, also make sure that it's >0 */
3315 	interval = max_t(u16, 1, request->interval / 1000);
3316 
3317 	ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
3318 				  interval, interval,
3319 				  vif->bg_scan_period, 0, 0, 0, 3, 0, 0, 0);
3320 
3321 	/* this also clears IE in fw if it's not set */
3322 	ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
3323 				       WMI_FRAME_PROBE_REQ,
3324 				       request->ie, request->ie_len);
3325 	if (ret) {
3326 		ath6kl_warn("Failed to set probe request IE for scheduled scan: %d\n",
3327 			    ret);
3328 		return ret;
3329 	}
3330 
3331 	ret = ath6kl_wmi_enable_sched_scan_cmd(ar->wmi, vif->fw_vif_idx, true);
3332 	if (ret)
3333 		return ret;
3334 
3335 	set_bit(SCHED_SCANNING, &vif->flags);
3336 
3337 	return 0;
3338 }
3339 
3340 static int ath6kl_cfg80211_sscan_stop(struct wiphy *wiphy,
3341 				      struct net_device *dev)
3342 {
3343 	struct ath6kl_vif *vif = netdev_priv(dev);
3344 	bool stopped;
3345 
3346 	stopped = __ath6kl_cfg80211_sscan_stop(vif);
3347 
3348 	if (!stopped)
3349 		return -EIO;
3350 
3351 	return 0;
3352 }
3353 
3354 static int ath6kl_cfg80211_set_bitrate(struct wiphy *wiphy,
3355 				       struct net_device *dev,
3356 				       const u8 *addr,
3357 				       const struct cfg80211_bitrate_mask *mask)
3358 {
3359 	struct ath6kl *ar = ath6kl_priv(dev);
3360 	struct ath6kl_vif *vif = netdev_priv(dev);
3361 
3362 	return ath6kl_wmi_set_bitrate_mask(ar->wmi, vif->fw_vif_idx,
3363 					   mask);
3364 }
3365 
3366 static int ath6kl_cfg80211_set_txe_config(struct wiphy *wiphy,
3367 					  struct net_device *dev,
3368 					  u32 rate, u32 pkts, u32 intvl)
3369 {
3370 	struct ath6kl *ar = ath6kl_priv(dev);
3371 	struct ath6kl_vif *vif = netdev_priv(dev);
3372 
3373 	if (vif->nw_type != INFRA_NETWORK ||
3374 	    !test_bit(ATH6KL_FW_CAPABILITY_TX_ERR_NOTIFY, ar->fw_capabilities))
3375 		return -EOPNOTSUPP;
3376 
3377 	if (vif->sme_state != SME_CONNECTED)
3378 		return -ENOTCONN;
3379 
3380 	/* save this since the firmware won't report the interval */
3381 	vif->txe_intvl = intvl;
3382 
3383 	return ath6kl_wmi_set_txe_notify(ar->wmi, vif->fw_vif_idx,
3384 					 rate, pkts, intvl);
3385 }
3386 
3387 static const struct ieee80211_txrx_stypes
3388 ath6kl_mgmt_stypes[NUM_NL80211_IFTYPES] = {
3389 	[NL80211_IFTYPE_STATION] = {
3390 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3391 		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3392 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3393 		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3394 	},
3395 	[NL80211_IFTYPE_AP] = {
3396 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3397 		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3398 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3399 		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3400 	},
3401 	[NL80211_IFTYPE_P2P_CLIENT] = {
3402 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3403 		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3404 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3405 		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3406 	},
3407 	[NL80211_IFTYPE_P2P_GO] = {
3408 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3409 		BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
3410 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
3411 		BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
3412 	},
3413 };
3414 
3415 static struct cfg80211_ops ath6kl_cfg80211_ops = {
3416 	.add_virtual_intf = ath6kl_cfg80211_add_iface,
3417 	.del_virtual_intf = ath6kl_cfg80211_del_iface,
3418 	.change_virtual_intf = ath6kl_cfg80211_change_iface,
3419 	.scan = ath6kl_cfg80211_scan,
3420 	.connect = ath6kl_cfg80211_connect,
3421 	.disconnect = ath6kl_cfg80211_disconnect,
3422 	.add_key = ath6kl_cfg80211_add_key,
3423 	.get_key = ath6kl_cfg80211_get_key,
3424 	.del_key = ath6kl_cfg80211_del_key,
3425 	.set_default_key = ath6kl_cfg80211_set_default_key,
3426 	.set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
3427 	.set_tx_power = ath6kl_cfg80211_set_txpower,
3428 	.get_tx_power = ath6kl_cfg80211_get_txpower,
3429 	.set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
3430 	.join_ibss = ath6kl_cfg80211_join_ibss,
3431 	.leave_ibss = ath6kl_cfg80211_leave_ibss,
3432 	.get_station = ath6kl_get_station,
3433 	.set_pmksa = ath6kl_set_pmksa,
3434 	.del_pmksa = ath6kl_del_pmksa,
3435 	.flush_pmksa = ath6kl_flush_pmksa,
3436 	CFG80211_TESTMODE_CMD(ath6kl_tm_cmd)
3437 #ifdef CONFIG_PM
3438 	.suspend = __ath6kl_cfg80211_suspend,
3439 	.resume = __ath6kl_cfg80211_resume,
3440 #endif
3441 	.start_ap = ath6kl_start_ap,
3442 	.change_beacon = ath6kl_change_beacon,
3443 	.stop_ap = ath6kl_stop_ap,
3444 	.del_station = ath6kl_del_station,
3445 	.change_station = ath6kl_change_station,
3446 	.remain_on_channel = ath6kl_remain_on_channel,
3447 	.cancel_remain_on_channel = ath6kl_cancel_remain_on_channel,
3448 	.mgmt_tx = ath6kl_mgmt_tx,
3449 	.mgmt_frame_register = ath6kl_mgmt_frame_register,
3450 	.sched_scan_start = ath6kl_cfg80211_sscan_start,
3451 	.sched_scan_stop = ath6kl_cfg80211_sscan_stop,
3452 	.set_bitrate_mask = ath6kl_cfg80211_set_bitrate,
3453 	.set_cqm_txe_config = ath6kl_cfg80211_set_txe_config,
3454 };
3455 
3456 void ath6kl_cfg80211_stop(struct ath6kl_vif *vif)
3457 {
3458 	ath6kl_cfg80211_sscan_disable(vif);
3459 
3460 	switch (vif->sme_state) {
3461 	case SME_DISCONNECTED:
3462 		break;
3463 	case SME_CONNECTING:
3464 		cfg80211_connect_result(vif->ndev, vif->bssid, NULL, 0,
3465 					NULL, 0,
3466 					WLAN_STATUS_UNSPECIFIED_FAILURE,
3467 					GFP_KERNEL);
3468 		break;
3469 	case SME_CONNECTED:
3470 		cfg80211_disconnected(vif->ndev, 0, NULL, 0, true, GFP_KERNEL);
3471 		break;
3472 	}
3473 
3474 	if (vif->ar->state != ATH6KL_STATE_RECOVERY &&
3475 	    (test_bit(CONNECTED, &vif->flags) ||
3476 	    test_bit(CONNECT_PEND, &vif->flags)))
3477 		ath6kl_wmi_disconnect_cmd(vif->ar->wmi, vif->fw_vif_idx);
3478 
3479 	vif->sme_state = SME_DISCONNECTED;
3480 	clear_bit(CONNECTED, &vif->flags);
3481 	clear_bit(CONNECT_PEND, &vif->flags);
3482 
3483 	/* Stop netdev queues, needed during recovery */
3484 	netif_stop_queue(vif->ndev);
3485 	netif_carrier_off(vif->ndev);
3486 
3487 	/* disable scanning */
3488 	if (vif->ar->state != ATH6KL_STATE_RECOVERY &&
3489 	    ath6kl_wmi_scanparams_cmd(vif->ar->wmi, vif->fw_vif_idx, 0xFFFF,
3490 				      0, 0, 0, 0, 0, 0, 0, 0, 0) != 0)
3491 		ath6kl_warn("failed to disable scan during stop\n");
3492 
3493 	ath6kl_cfg80211_scan_complete_event(vif, true);
3494 }
3495 
3496 void ath6kl_cfg80211_stop_all(struct ath6kl *ar)
3497 {
3498 	struct ath6kl_vif *vif;
3499 
3500 	vif = ath6kl_vif_first(ar);
3501 	if (!vif && ar->state != ATH6KL_STATE_RECOVERY) {
3502 		/* save the current power mode before enabling power save */
3503 		ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
3504 
3505 		if (ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER) != 0)
3506 			ath6kl_warn("ath6kl_deep_sleep_enable: wmi_powermode_cmd failed\n");
3507 		return;
3508 	}
3509 
3510 	/*
3511 	 * FIXME: we should take ar->list_lock to protect changes in the
3512 	 * vif_list, but that's not trivial to do as ath6kl_cfg80211_stop()
3513 	 * sleeps.
3514 	 */
3515 	list_for_each_entry(vif, &ar->vif_list, list)
3516 		ath6kl_cfg80211_stop(vif);
3517 }
3518 
3519 static void ath6kl_cfg80211_reg_notify(struct wiphy *wiphy,
3520 				       struct regulatory_request *request)
3521 {
3522 	struct ath6kl *ar = wiphy_priv(wiphy);
3523 	u32 rates[IEEE80211_NUM_BANDS];
3524 	int ret, i;
3525 
3526 	ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
3527 		   "cfg reg_notify %c%c%s%s initiator %d hint_type %d\n",
3528 		   request->alpha2[0], request->alpha2[1],
3529 		   request->intersect ? " intersect" : "",
3530 		   request->processed ? " processed" : "",
3531 		   request->initiator, request->user_reg_hint_type);
3532 
3533 	if (request->user_reg_hint_type != NL80211_USER_REG_HINT_CELL_BASE)
3534 		return;
3535 
3536 	ret = ath6kl_wmi_set_regdomain_cmd(ar->wmi, request->alpha2);
3537 	if (ret) {
3538 		ath6kl_err("failed to set regdomain: %d\n", ret);
3539 		return;
3540 	}
3541 
3542 	/*
3543 	 * Firmware will apply the regdomain change only after a scan is
3544 	 * issued and it will send a WMI_REGDOMAIN_EVENTID when it has been
3545 	 * changed.
3546 	 */
3547 
3548 	for (i = 0; i < IEEE80211_NUM_BANDS; i++)
3549 		if (wiphy->bands[i])
3550 			rates[i] = (1 << wiphy->bands[i]->n_bitrates) - 1;
3551 
3552 
3553 	ret = ath6kl_wmi_beginscan_cmd(ar->wmi, 0, WMI_LONG_SCAN, false,
3554 				       false, 0, ATH6KL_FG_SCAN_INTERVAL,
3555 				       0, NULL, false, rates);
3556 	if (ret) {
3557 		ath6kl_err("failed to start scan for a regdomain change: %d\n",
3558 			   ret);
3559 		return;
3560 	}
3561 }
3562 
3563 static int ath6kl_cfg80211_vif_init(struct ath6kl_vif *vif)
3564 {
3565 	vif->aggr_cntxt = aggr_init(vif);
3566 	if (!vif->aggr_cntxt) {
3567 		ath6kl_err("failed to initialize aggr\n");
3568 		return -ENOMEM;
3569 	}
3570 
3571 	setup_timer(&vif->disconnect_timer, disconnect_timer_handler,
3572 		    (unsigned long) vif->ndev);
3573 	setup_timer(&vif->sched_scan_timer, ath6kl_wmi_sscan_timer,
3574 		    (unsigned long) vif);
3575 
3576 	set_bit(WMM_ENABLED, &vif->flags);
3577 	spin_lock_init(&vif->if_lock);
3578 
3579 	INIT_LIST_HEAD(&vif->mc_filter);
3580 
3581 	return 0;
3582 }
3583 
3584 void ath6kl_cfg80211_vif_stop(struct ath6kl_vif *vif, bool wmi_ready)
3585 {
3586 	static u8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3587 	bool discon_issued;
3588 
3589 	netif_stop_queue(vif->ndev);
3590 
3591 	clear_bit(WLAN_ENABLED, &vif->flags);
3592 
3593 	if (wmi_ready) {
3594 		discon_issued = test_bit(CONNECTED, &vif->flags) ||
3595 				test_bit(CONNECT_PEND, &vif->flags);
3596 		ath6kl_disconnect(vif);
3597 		del_timer(&vif->disconnect_timer);
3598 
3599 		if (discon_issued)
3600 			ath6kl_disconnect_event(vif, DISCONNECT_CMD,
3601 						(vif->nw_type & AP_NETWORK) ?
3602 						bcast_mac : vif->bssid,
3603 						0, NULL, 0);
3604 	}
3605 
3606 	if (vif->scan_req) {
3607 		cfg80211_scan_done(vif->scan_req, true);
3608 		vif->scan_req = NULL;
3609 	}
3610 
3611 	/* need to clean up enhanced bmiss detection fw state */
3612 	ath6kl_cfg80211_sta_bmiss_enhance(vif, false);
3613 }
3614 
3615 void ath6kl_cfg80211_vif_cleanup(struct ath6kl_vif *vif)
3616 {
3617 	struct ath6kl *ar = vif->ar;
3618 	struct ath6kl_mc_filter *mc_filter, *tmp;
3619 
3620 	aggr_module_destroy(vif->aggr_cntxt);
3621 
3622 	ar->avail_idx_map |= BIT(vif->fw_vif_idx);
3623 
3624 	if (vif->nw_type == ADHOC_NETWORK)
3625 		ar->ibss_if_active = false;
3626 
3627 	list_for_each_entry_safe(mc_filter, tmp, &vif->mc_filter, list) {
3628 		list_del(&mc_filter->list);
3629 		kfree(mc_filter);
3630 	}
3631 
3632 	unregister_netdevice(vif->ndev);
3633 
3634 	ar->num_vif--;
3635 }
3636 
3637 struct wireless_dev *ath6kl_interface_add(struct ath6kl *ar, const char *name,
3638 					  unsigned char name_assign_type,
3639 					  enum nl80211_iftype type,
3640 					  u8 fw_vif_idx, u8 nw_type)
3641 {
3642 	struct net_device *ndev;
3643 	struct ath6kl_vif *vif;
3644 
3645 	ndev = alloc_netdev(sizeof(*vif), name, name_assign_type, ether_setup);
3646 	if (!ndev)
3647 		return NULL;
3648 
3649 	vif = netdev_priv(ndev);
3650 	ndev->ieee80211_ptr = &vif->wdev;
3651 	vif->wdev.wiphy = ar->wiphy;
3652 	vif->ar = ar;
3653 	vif->ndev = ndev;
3654 	SET_NETDEV_DEV(ndev, wiphy_dev(vif->wdev.wiphy));
3655 	vif->wdev.netdev = ndev;
3656 	vif->wdev.iftype = type;
3657 	vif->fw_vif_idx = fw_vif_idx;
3658 	vif->nw_type = nw_type;
3659 	vif->next_mode = nw_type;
3660 	vif->listen_intvl_t = ATH6KL_DEFAULT_LISTEN_INTVAL;
3661 	vif->bmiss_time_t = ATH6KL_DEFAULT_BMISS_TIME;
3662 	vif->bg_scan_period = 0;
3663 	vif->htcap[IEEE80211_BAND_2GHZ].ht_enable = true;
3664 	vif->htcap[IEEE80211_BAND_5GHZ].ht_enable = true;
3665 
3666 	memcpy(ndev->dev_addr, ar->mac_addr, ETH_ALEN);
3667 	if (fw_vif_idx != 0) {
3668 		ndev->dev_addr[0] = (ndev->dev_addr[0] ^ (1 << fw_vif_idx)) |
3669 				     0x2;
3670 		if (test_bit(ATH6KL_FW_CAPABILITY_CUSTOM_MAC_ADDR,
3671 			     ar->fw_capabilities))
3672 			ndev->dev_addr[4] ^= 0x80;
3673 	}
3674 
3675 	init_netdev(ndev);
3676 
3677 	ath6kl_init_control_info(vif);
3678 
3679 	if (ath6kl_cfg80211_vif_init(vif))
3680 		goto err;
3681 
3682 	if (register_netdevice(ndev))
3683 		goto err;
3684 
3685 	ar->avail_idx_map &= ~BIT(fw_vif_idx);
3686 	vif->sme_state = SME_DISCONNECTED;
3687 	set_bit(WLAN_ENABLED, &vif->flags);
3688 	ar->wlan_pwr_state = WLAN_POWER_STATE_ON;
3689 
3690 	if (type == NL80211_IFTYPE_ADHOC)
3691 		ar->ibss_if_active = true;
3692 
3693 	spin_lock_bh(&ar->list_lock);
3694 	list_add_tail(&vif->list, &ar->vif_list);
3695 	spin_unlock_bh(&ar->list_lock);
3696 
3697 	return &vif->wdev;
3698 
3699 err:
3700 	aggr_module_destroy(vif->aggr_cntxt);
3701 	free_netdev(ndev);
3702 	return NULL;
3703 }
3704 
3705 #ifdef CONFIG_PM
3706 static const struct wiphy_wowlan_support ath6kl_wowlan_support = {
3707 	.flags = WIPHY_WOWLAN_MAGIC_PKT |
3708 		 WIPHY_WOWLAN_DISCONNECT |
3709 		 WIPHY_WOWLAN_GTK_REKEY_FAILURE  |
3710 		 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
3711 		 WIPHY_WOWLAN_EAP_IDENTITY_REQ   |
3712 		 WIPHY_WOWLAN_4WAY_HANDSHAKE,
3713 	.n_patterns = WOW_MAX_FILTERS_PER_LIST,
3714 	.pattern_min_len = 1,
3715 	.pattern_max_len = WOW_PATTERN_SIZE,
3716 };
3717 #endif
3718 
3719 int ath6kl_cfg80211_init(struct ath6kl *ar)
3720 {
3721 	struct wiphy *wiphy = ar->wiphy;
3722 	bool band_2gig = false, band_5gig = false, ht = false;
3723 	int ret;
3724 
3725 	wiphy->mgmt_stypes = ath6kl_mgmt_stypes;
3726 
3727 	wiphy->max_remain_on_channel_duration = 5000;
3728 
3729 	/* set device pointer for wiphy */
3730 	set_wiphy_dev(wiphy, ar->dev);
3731 
3732 	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3733 				 BIT(NL80211_IFTYPE_ADHOC) |
3734 				 BIT(NL80211_IFTYPE_AP);
3735 	if (ar->p2p) {
3736 		wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_GO) |
3737 					  BIT(NL80211_IFTYPE_P2P_CLIENT);
3738 	}
3739 
3740 	if (config_enabled(CONFIG_ATH6KL_REGDOMAIN) &&
3741 	    test_bit(ATH6KL_FW_CAPABILITY_REGDOMAIN, ar->fw_capabilities)) {
3742 		wiphy->reg_notifier = ath6kl_cfg80211_reg_notify;
3743 		ar->wiphy->features |= NL80211_FEATURE_CELL_BASE_REG_HINTS;
3744 	}
3745 
3746 	/* max num of ssids that can be probed during scanning */
3747 	wiphy->max_scan_ssids = MAX_PROBED_SSIDS;
3748 
3749 	/* max num of ssids that can be matched after scan */
3750 	if (test_bit(ATH6KL_FW_CAPABILITY_SCHED_SCAN_MATCH_LIST,
3751 		     ar->fw_capabilities))
3752 		wiphy->max_match_sets = MAX_PROBED_SSIDS;
3753 
3754 	wiphy->max_scan_ie_len = 1000; /* FIX: what is correct limit? */
3755 	switch (ar->hw.cap) {
3756 	case WMI_11AN_CAP:
3757 		ht = true;
3758 	case WMI_11A_CAP:
3759 		band_5gig = true;
3760 		break;
3761 	case WMI_11GN_CAP:
3762 		ht = true;
3763 	case WMI_11G_CAP:
3764 		band_2gig = true;
3765 		break;
3766 	case WMI_11AGN_CAP:
3767 		ht = true;
3768 	case WMI_11AG_CAP:
3769 		band_2gig = true;
3770 		band_5gig = true;
3771 		break;
3772 	default:
3773 		ath6kl_err("invalid phy capability!\n");
3774 		return -EINVAL;
3775 	}
3776 
3777 	/*
3778 	 * Even if the fw has HT support, advertise HT cap only when
3779 	 * the firmware has support to override RSN capability, otherwise
3780 	 * 4-way handshake would fail.
3781 	 */
3782 	if (!(ht &&
3783 	      test_bit(ATH6KL_FW_CAPABILITY_RSN_CAP_OVERRIDE,
3784 		       ar->fw_capabilities))) {
3785 		ath6kl_band_2ghz.ht_cap.cap = 0;
3786 		ath6kl_band_2ghz.ht_cap.ht_supported = false;
3787 		ath6kl_band_5ghz.ht_cap.cap = 0;
3788 		ath6kl_band_5ghz.ht_cap.ht_supported = false;
3789 	}
3790 
3791 	if (test_bit(ATH6KL_FW_CAPABILITY_64BIT_RATES,
3792 		     ar->fw_capabilities)) {
3793 		ath6kl_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3794 		ath6kl_band_5ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3795 		ath6kl_band_2ghz.ht_cap.mcs.rx_mask[1] = 0xff;
3796 		ath6kl_band_5ghz.ht_cap.mcs.rx_mask[1] = 0xff;
3797 	} else {
3798 		ath6kl_band_2ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3799 		ath6kl_band_5ghz.ht_cap.mcs.rx_mask[0] = 0xff;
3800 	}
3801 
3802 	if (band_2gig)
3803 		wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
3804 	if (band_5gig)
3805 		wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
3806 
3807 	wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3808 
3809 	wiphy->cipher_suites = cipher_suites;
3810 	wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3811 
3812 #ifdef CONFIG_PM
3813 	wiphy->wowlan = &ath6kl_wowlan_support;
3814 #endif
3815 
3816 	wiphy->max_sched_scan_ssids = MAX_PROBED_SSIDS;
3817 
3818 	ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM |
3819 			    WIPHY_FLAG_HAVE_AP_SME |
3820 			    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
3821 			    WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
3822 
3823 	if (test_bit(ATH6KL_FW_CAPABILITY_SCHED_SCAN_V2, ar->fw_capabilities))
3824 		ar->wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
3825 
3826 	if (test_bit(ATH6KL_FW_CAPABILITY_INACTIVITY_TIMEOUT,
3827 		     ar->fw_capabilities))
3828 		ar->wiphy->features |= NL80211_FEATURE_INACTIVITY_TIMER;
3829 
3830 	ar->wiphy->probe_resp_offload =
3831 		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
3832 		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
3833 		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
3834 
3835 	ret = wiphy_register(wiphy);
3836 	if (ret < 0) {
3837 		ath6kl_err("couldn't register wiphy device\n");
3838 		return ret;
3839 	}
3840 
3841 	ar->wiphy_registered = true;
3842 
3843 	return 0;
3844 }
3845 
3846 void ath6kl_cfg80211_cleanup(struct ath6kl *ar)
3847 {
3848 	wiphy_unregister(ar->wiphy);
3849 
3850 	ar->wiphy_registered = false;
3851 }
3852 
3853 struct ath6kl *ath6kl_cfg80211_create(void)
3854 {
3855 	struct ath6kl *ar;
3856 	struct wiphy *wiphy;
3857 
3858 	/* create a new wiphy for use with cfg80211 */
3859 	wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
3860 
3861 	if (!wiphy) {
3862 		ath6kl_err("couldn't allocate wiphy device\n");
3863 		return NULL;
3864 	}
3865 
3866 	ar = wiphy_priv(wiphy);
3867 	ar->wiphy = wiphy;
3868 
3869 	return ar;
3870 }
3871 
3872 /* Note: ar variable must not be accessed after calling this! */
3873 void ath6kl_cfg80211_destroy(struct ath6kl *ar)
3874 {
3875 	int i;
3876 
3877 	for (i = 0; i < AP_MAX_NUM_STA; i++)
3878 		kfree(ar->sta_list[i].aggr_conn);
3879 
3880 	wiphy_free(ar->wiphy);
3881 }
3882 
3883