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