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