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