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