?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / net / wireless / ath / ath6kl / cfg80211.c
blob6c59a217b1a133f390d1dd2f444494110660b9f7
1 /*
2 * Copyright (c) 2004-2011 Atheros Communications Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #include <linux/moduleparam.h>
18
19 #include "core.h"
20 #include "cfg80211.h"
21 #include "debug.h"
22 #include "hif-ops.h"
23 #include "testmode.h"
24
25 static unsigned int ath6kl_p2p;
26
27 module_param(ath6kl_p2p, uint, 0644);
28
29 #define RATETAB_ENT(_rate, _rateid, _flags) { \
30 .bitrate = (_rate), \
31 .flags = (_flags), \
32 .hw_value = (_rateid), \
33 }
34
35 #define CHAN2G(_channel, _freq, _flags) { \
36 .band = IEEE80211_BAND_2GHZ, \
37 .hw_value = (_channel), \
38 .center_freq = (_freq), \
39 .flags = (_flags), \
40 .max_antenna_gain = 0, \
41 .max_power = 30, \
42 }
43
44 #define CHAN5G(_channel, _flags) { \
45 .band = IEEE80211_BAND_5GHZ, \
46 .hw_value = (_channel), \
47 .center_freq = 5000 + (5 * (_channel)), \
48 .flags = (_flags), \
49 .max_antenna_gain = 0, \
50 .max_power = 30, \
51 }
52
53 static struct ieee80211_rate ath6kl_rates[] = {
54 RATETAB_ENT(10, 0x1, 0),
55 RATETAB_ENT(20, 0x2, 0),
56 RATETAB_ENT(55, 0x4, 0),
57 RATETAB_ENT(110, 0x8, 0),
58 RATETAB_ENT(60, 0x10, 0),
59 RATETAB_ENT(90, 0x20, 0),
60 RATETAB_ENT(120, 0x40, 0),
61 RATETAB_ENT(180, 0x80, 0),
62 RATETAB_ENT(240, 0x100, 0),
63 RATETAB_ENT(360, 0x200, 0),
64 RATETAB_ENT(480, 0x400, 0),
65 RATETAB_ENT(540, 0x800, 0),
66 };
67
68 #define ath6kl_a_rates (ath6kl_rates + 4)
69 #define ath6kl_a_rates_size 8
70 #define ath6kl_g_rates (ath6kl_rates + 0)
71 #define ath6kl_g_rates_size 12
72
73 static struct ieee80211_channel ath6kl_2ghz_channels[] = {
74 CHAN2G(1, 2412, 0),
75 CHAN2G(2, 2417, 0),
76 CHAN2G(3, 2422, 0),
77 CHAN2G(4, 2427, 0),
78 CHAN2G(5, 2432, 0),
79 CHAN2G(6, 2437, 0),
80 CHAN2G(7, 2442, 0),
81 CHAN2G(8, 2447, 0),
82 CHAN2G(9, 2452, 0),
83 CHAN2G(10, 2457, 0),
84 CHAN2G(11, 2462, 0),
85 CHAN2G(12, 2467, 0),
86 CHAN2G(13, 2472, 0),
87 CHAN2G(14, 2484, 0),
88 };
89
90 static struct ieee80211_channel ath6kl_5ghz_a_channels[] = {
91 CHAN5G(34, 0), CHAN5G(36, 0),
92 CHAN5G(38, 0), CHAN5G(40, 0),
93 CHAN5G(42, 0), CHAN5G(44, 0),
94 CHAN5G(46, 0), CHAN5G(48, 0),
95 CHAN5G(52, 0), CHAN5G(56, 0),
96 CHAN5G(60, 0), CHAN5G(64, 0),
97 CHAN5G(100, 0), CHAN5G(104, 0),
98 CHAN5G(108, 0), CHAN5G(112, 0),
99 CHAN5G(116, 0), CHAN5G(120, 0),
100 CHAN5G(124, 0), CHAN5G(128, 0),
101 CHAN5G(132, 0), CHAN5G(136, 0),
102 CHAN5G(140, 0), CHAN5G(149, 0),
103 CHAN5G(153, 0), CHAN5G(157, 0),
104 CHAN5G(161, 0), CHAN5G(165, 0),
105 CHAN5G(184, 0), CHAN5G(188, 0),
106 CHAN5G(192, 0), CHAN5G(196, 0),
107 CHAN5G(200, 0), CHAN5G(204, 0),
108 CHAN5G(208, 0), CHAN5G(212, 0),
109 CHAN5G(216, 0),
110 };
111
112 static struct ieee80211_supported_band ath6kl_band_2ghz = {
113 .n_channels = ARRAY_SIZE(ath6kl_2ghz_channels),
114 .channels = ath6kl_2ghz_channels,
115 .n_bitrates = ath6kl_g_rates_size,
116 .bitrates = ath6kl_g_rates,
117 };
118
119 static struct ieee80211_supported_band ath6kl_band_5ghz = {
120 .n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels),
121 .channels = ath6kl_5ghz_a_channels,
122 .n_bitrates = ath6kl_a_rates_size,
123 .bitrates = ath6kl_a_rates,
124 };
125
126 #define CCKM_KRK_CIPHER_SUITE 0x004096ff /* use for KRK */
127
128 /* returns true if scheduled scan was stopped */
129 static bool __ath6kl_cfg80211_sscan_stop(struct ath6kl_vif *vif)
130 {
131 struct ath6kl *ar = vif->ar;
132
133 if (ar->state != ATH6KL_STATE_SCHED_SCAN)
134 return false;
135
136 del_timer_sync(&vif->sched_scan_timer);
137
138 ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
139 ATH6KL_HOST_MODE_AWAKE);
140
141 ar->state = ATH6KL_STATE_ON;
142
143 return true;
144 }
145
146 static void ath6kl_cfg80211_sscan_disable(struct ath6kl_vif *vif)
147 {
148 struct ath6kl *ar = vif->ar;
149 bool stopped;
150
151 stopped = __ath6kl_cfg80211_sscan_stop(vif);
152
153 if (!stopped)
154 return;
155
156 cfg80211_sched_scan_stopped(ar->wiphy);
157 }
158
159 static int ath6kl_set_wpa_version(struct ath6kl_vif *vif,
160 enum nl80211_wpa_versions wpa_version)
161 {
162 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
163
164 if (!wpa_version) {
165 vif->auth_mode = NONE_AUTH;
166 } else if (wpa_version & NL80211_WPA_VERSION_2) {
167 vif->auth_mode = WPA2_AUTH;
168 } else if (wpa_version & NL80211_WPA_VERSION_1) {
169 vif->auth_mode = WPA_AUTH;
170 } else {
171 ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
172 return -ENOTSUPP;
173 }
174
175 return 0;
176 }
177
178 static int ath6kl_set_auth_type(struct ath6kl_vif *vif,
179 enum nl80211_auth_type auth_type)
180 {
181 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
182
183 switch (auth_type) {
184 case NL80211_AUTHTYPE_OPEN_SYSTEM:
185 vif->dot11_auth_mode = OPEN_AUTH;
186 break;
187 case NL80211_AUTHTYPE_SHARED_KEY:
188 vif->dot11_auth_mode = SHARED_AUTH;
189 break;
190 case NL80211_AUTHTYPE_NETWORK_EAP:
191 vif->dot11_auth_mode = LEAP_AUTH;
192 break;
193
194 case NL80211_AUTHTYPE_AUTOMATIC:
195 vif->dot11_auth_mode = OPEN_AUTH | SHARED_AUTH;
196 break;
197
198 default:
199 ath6kl_err("%s: 0x%x not spported\n", __func__, auth_type);
200 return -ENOTSUPP;
201 }
202
203 return 0;
204 }
205
206 static int ath6kl_set_cipher(struct ath6kl_vif *vif, u32 cipher, bool ucast)
207 {
208 u8 *ar_cipher = ucast ? &vif->prwise_crypto : &vif->grp_crypto;
209 u8 *ar_cipher_len = ucast ? &vif->prwise_crypto_len :
210 &vif->grp_crypto_len;
211
212 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
213 __func__, cipher, ucast);
214
215 switch (cipher) {
216 case 0:
217 /* our own hack to use value 0 as no crypto used */
218 *ar_cipher = NONE_CRYPT;
219 *ar_cipher_len = 0;
220 break;
221 case WLAN_CIPHER_SUITE_WEP40:
222 *ar_cipher = WEP_CRYPT;
223 *ar_cipher_len = 5;
224 break;
225 case WLAN_CIPHER_SUITE_WEP104:
226 *ar_cipher = WEP_CRYPT;
227 *ar_cipher_len = 13;
228 break;
229 case WLAN_CIPHER_SUITE_TKIP:
230 *ar_cipher = TKIP_CRYPT;
231 *ar_cipher_len = 0;
232 break;
233 case WLAN_CIPHER_SUITE_CCMP:
234 *ar_cipher = AES_CRYPT;
235 *ar_cipher_len = 0;
236 break;
237 case WLAN_CIPHER_SUITE_SMS4:
238 *ar_cipher = WAPI_CRYPT;
239 *ar_cipher_len = 0;
240 break;
241 default:
242 ath6kl_err("cipher 0x%x not supported\n", cipher);
243 return -ENOTSUPP;
244 }
245
246 return 0;
247 }
248
249 static void ath6kl_set_key_mgmt(struct ath6kl_vif *vif, u32 key_mgmt)
250 {
251 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
252
253 if (key_mgmt == WLAN_AKM_SUITE_PSK) {
254 if (vif->auth_mode == WPA_AUTH)
255 vif->auth_mode = WPA_PSK_AUTH;
256 else if (vif->auth_mode == WPA2_AUTH)
257 vif->auth_mode = WPA2_PSK_AUTH;
258 } else if (key_mgmt == 0x00409600) {
259 if (vif->auth_mode == WPA_AUTH)
260 vif->auth_mode = WPA_AUTH_CCKM;
261 else if (vif->auth_mode == WPA2_AUTH)
262 vif->auth_mode = WPA2_AUTH_CCKM;
263 } else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
264 vif->auth_mode = NONE_AUTH;
265 }
266 }
267
268 static bool ath6kl_cfg80211_ready(struct ath6kl_vif *vif)
269 {
270 struct ath6kl *ar = vif->ar;
271
272 if (!test_bit(WMI_READY, &ar->flag)) {
273 ath6kl_err("wmi is not ready\n");
274 return false;
275 }
276
277 if (!test_bit(WLAN_ENABLED, &vif->flags)) {
278 ath6kl_err("wlan disabled\n");
279 return false;
280 }
281
282 return true;
283 }
284
285 static bool ath6kl_is_wpa_ie(const u8 *pos)
286 {
287 return pos[0] == WLAN_EID_WPA && pos[1] >= 4 &&
288 pos[2] == 0x00 && pos[3] == 0x50 &&
289 pos[4] == 0xf2 && pos[5] == 0x01;
290 }
291
292 static bool ath6kl_is_rsn_ie(const u8 *pos)
293 {
294 return pos[0] == WLAN_EID_RSN;
295 }
296
297 static bool ath6kl_is_wps_ie(const u8 *pos)
298 {
299 return (pos[0] == WLAN_EID_VENDOR_SPECIFIC &&
300 pos[1] >= 4 &&
301 pos[2] == 0x00 && pos[3] == 0x50 && pos[4] == 0xf2 &&
302 pos[5] == 0x04);
303 }
304
305 static int ath6kl_set_assoc_req_ies(struct ath6kl_vif *vif, const u8 *ies,
306 size_t ies_len)
307 {
308 struct ath6kl *ar = vif->ar;
309 const u8 *pos;
310 u8 *buf = NULL;
311 size_t len = 0;
312 int ret;
313
314 /*
315 * Clear previously set flag
316 */
317
318 ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
319
320 /*
321 * Filter out RSN/WPA IE(s)
322 */
323
324 if (ies && ies_len) {
325 buf = kmalloc(ies_len, GFP_KERNEL);
326 if (buf == NULL)
327 return -ENOMEM;
328 pos = ies;
329
330 while (pos + 1 < ies + ies_len) {
331 if (pos + 2 + pos[1] > ies + ies_len)
332 break;
333 if (!(ath6kl_is_wpa_ie(pos) || ath6kl_is_rsn_ie(pos))) {
334 memcpy(buf + len, pos, 2 + pos[1]);
335 len += 2 + pos[1];
336 }
337
338 if (ath6kl_is_wps_ie(pos))
339 ar->connect_ctrl_flags |= CONNECT_WPS_FLAG;
340
341 pos += 2 + pos[1];
342 }
343 }
344
345 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
346 WMI_FRAME_ASSOC_REQ, buf, len);
347 kfree(buf);
348 return ret;
349 }
350
351 static int ath6kl_nliftype_to_drv_iftype(enum nl80211_iftype type, u8 *nw_type)
352 {
353 switch (type) {
354 case NL80211_IFTYPE_STATION:
355 *nw_type = INFRA_NETWORK;
356 break;
357 case NL80211_IFTYPE_ADHOC:
358 *nw_type = ADHOC_NETWORK;
359 break;
360 case NL80211_IFTYPE_AP:
361 *nw_type = AP_NETWORK;
362 break;
363 case NL80211_IFTYPE_P2P_CLIENT:
364 *nw_type = INFRA_NETWORK;
365 break;
366 case NL80211_IFTYPE_P2P_GO:
367 *nw_type = AP_NETWORK;
368 break;
369 default:
370 ath6kl_err("invalid interface type %u\n", type);
371 return -ENOTSUPP;
372 }
373
374 return 0;
375 }
376
377 static bool ath6kl_is_valid_iftype(struct ath6kl *ar, enum nl80211_iftype type,
378 u8 *if_idx, u8 *nw_type)
379 {
380 int i;
381
382 if (ath6kl_nliftype_to_drv_iftype(type, nw_type))
383 return false;
384
385 if (ar->ibss_if_active || ((type == NL80211_IFTYPE_ADHOC) &&
386 ar->num_vif))
387 return false;
388
389 if (type == NL80211_IFTYPE_STATION ||
390 type == NL80211_IFTYPE_AP || type == NL80211_IFTYPE_ADHOC) {
391 for (i = 0; i < ar->vif_max; i++) {
392 if ((ar->avail_idx_map >> i) & BIT(0)) {
393 *if_idx = i;
394 return true;
395 }
396 }
397 }
398
399 if (type == NL80211_IFTYPE_P2P_CLIENT ||
400 type == NL80211_IFTYPE_P2P_GO) {
401 for (i = ar->max_norm_iface; i < ar->vif_max; i++) {
402 if ((ar->avail_idx_map >> i) & BIT(0)) {
403 *if_idx = i;
404 return true;
405 }
406 }
407 }
408
409 return false;
410 }
411
412 static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
413 struct cfg80211_connect_params *sme)
414 {
415 struct ath6kl *ar = ath6kl_priv(dev);
416 struct ath6kl_vif *vif = netdev_priv(dev);
417 int status;
418 u8 nw_subtype = (ar->p2p) ? SUBTYPE_P2PDEV : SUBTYPE_NONE;
419
420 ath6kl_cfg80211_sscan_disable(vif);
421
422 vif->sme_state = SME_CONNECTING;
423
424 if (!ath6kl_cfg80211_ready(vif))
425 return -EIO;
426
427 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
428 ath6kl_err("destroy in progress\n");
429 return -EBUSY;
430 }
431
432 if (test_bit(SKIP_SCAN, &ar->flag) &&
433 ((sme->channel && sme->channel->center_freq == 0) ||
434 (sme->bssid && is_zero_ether_addr(sme->bssid)))) {
435 ath6kl_err("SkipScan: channel or bssid invalid\n");
436 return -EINVAL;
437 }
438
439 if (down_interruptible(&ar->sem)) {
440 ath6kl_err("busy, couldn't get access\n");
441 return -ERESTARTSYS;
442 }
443
444 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
445 ath6kl_err("busy, destroy in progress\n");
446 up(&ar->sem);
447 return -EBUSY;
448 }
449
450 if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) {
451 /*
452 * sleep until the command queue drains
453 */
454 wait_event_interruptible_timeout(ar->event_wq,
455 ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0,
456 WMI_TIMEOUT);
457 if (signal_pending(current)) {
458 ath6kl_err("cmd queue drain timeout\n");
459 up(&ar->sem);
460 return -EINTR;
461 }
462 }
463
464 if (sme->ie && (sme->ie_len > 0)) {
465 status = ath6kl_set_assoc_req_ies(vif, sme->ie, sme->ie_len);
466 if (status) {
467 up(&ar->sem);
468 return status;
469 }
470 } else
471 ar->connect_ctrl_flags &= ~CONNECT_WPS_FLAG;
472
473 if (test_bit(CONNECTED, &vif->flags) &&
474 vif->ssid_len == sme->ssid_len &&
475 !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
476 vif->reconnect_flag = true;
477 status = ath6kl_wmi_reconnect_cmd(ar->wmi, vif->fw_vif_idx,
478 vif->req_bssid,
479 vif->ch_hint);
480
481 up(&ar->sem);
482 if (status) {
483 ath6kl_err("wmi_reconnect_cmd failed\n");
484 return -EIO;
485 }
486 return 0;
487 } else if (vif->ssid_len == sme->ssid_len &&
488 !memcmp(vif->ssid, sme->ssid, vif->ssid_len)) {
489 ath6kl_disconnect(vif);
490 }
491
492 memset(vif->ssid, 0, sizeof(vif->ssid));
493 vif->ssid_len = sme->ssid_len;
494 memcpy(vif->ssid, sme->ssid, sme->ssid_len);
495
496 if (sme->channel)
497 vif->ch_hint = sme->channel->center_freq;
498
499 memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
500 if (sme->bssid && !is_broadcast_ether_addr(sme->bssid))
501 memcpy(vif->req_bssid, sme->bssid, sizeof(vif->req_bssid));
502
503 ath6kl_set_wpa_version(vif, sme->crypto.wpa_versions);
504
505 status = ath6kl_set_auth_type(vif, sme->auth_type);
506 if (status) {
507 up(&ar->sem);
508 return status;
509 }
510
511 if (sme->crypto.n_ciphers_pairwise)
512 ath6kl_set_cipher(vif, sme->crypto.ciphers_pairwise[0], true);
513 else
514 ath6kl_set_cipher(vif, 0, true);
515
516 ath6kl_set_cipher(vif, sme->crypto.cipher_group, false);
517
518 if (sme->crypto.n_akm_suites)
519 ath6kl_set_key_mgmt(vif, sme->crypto.akm_suites[0]);
520
521 if ((sme->key_len) &&
522 (vif->auth_mode == NONE_AUTH) &&
523 (vif->prwise_crypto == WEP_CRYPT)) {
524 struct ath6kl_key *key = NULL;
525
526 if (sme->key_idx < WMI_MIN_KEY_INDEX ||
527 sme->key_idx > WMI_MAX_KEY_INDEX) {
528 ath6kl_err("key index %d out of bounds\n",
529 sme->key_idx);
530 up(&ar->sem);
531 return -ENOENT;
532 }
533
534 key = &vif->keys[sme->key_idx];
535 key->key_len = sme->key_len;
536 memcpy(key->key, sme->key, key->key_len);
537 key->cipher = vif->prwise_crypto;
538 vif->def_txkey_index = sme->key_idx;
539
540 ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, sme->key_idx,
541 vif->prwise_crypto,
542 GROUP_USAGE | TX_USAGE,
543 key->key_len,
544 NULL, 0,
545 key->key, KEY_OP_INIT_VAL, NULL,
546 NO_SYNC_WMIFLAG);
547 }
548
549 if (!ar->usr_bss_filter) {
550 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
551 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, vif->fw_vif_idx,
552 ALL_BSS_FILTER, 0) != 0) {
553 ath6kl_err("couldn't set bss filtering\n");
554 up(&ar->sem);
555 return -EIO;
556 }
557 }
558
559 vif->nw_type = vif->next_mode;
560
561 if (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT)
562 nw_subtype = SUBTYPE_P2PCLIENT;
563
564 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
565 "%s: connect called with authmode %d dot11 auth %d"
566 " PW crypto %d PW crypto len %d GRP crypto %d"
567 " GRP crypto len %d channel hint %u\n",
568 __func__,
569 vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
570 vif->prwise_crypto_len, vif->grp_crypto,
571 vif->grp_crypto_len, vif->ch_hint);
572
573 vif->reconnect_flag = 0;
574 status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
575 vif->dot11_auth_mode, vif->auth_mode,
576 vif->prwise_crypto,
577 vif->prwise_crypto_len,
578 vif->grp_crypto, vif->grp_crypto_len,
579 vif->ssid_len, vif->ssid,
580 vif->req_bssid, vif->ch_hint,
581 ar->connect_ctrl_flags, nw_subtype);
582
583 up(&ar->sem);
584
585 if (status == -EINVAL) {
586 memset(vif->ssid, 0, sizeof(vif->ssid));
587 vif->ssid_len = 0;
588 ath6kl_err("invalid request\n");
589 return -ENOENT;
590 } else if (status) {
591 ath6kl_err("ath6kl_wmi_connect_cmd failed\n");
592 return -EIO;
593 }
594
595 if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) &&
596 ((vif->auth_mode == WPA_PSK_AUTH)
597 || (vif->auth_mode == WPA2_PSK_AUTH))) {
598 mod_timer(&vif->disconnect_timer,
599 jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL));
600 }
601
602 ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD;
603 set_bit(CONNECT_PEND, &vif->flags);
604
605 return 0;
606 }
607
608 static int ath6kl_add_bss_if_needed(struct ath6kl_vif *vif,
609 enum network_type nw_type,
610 const u8 *bssid,
611 struct ieee80211_channel *chan,
612 const u8 *beacon_ie, size_t beacon_ie_len)
613 {
614 struct ath6kl *ar = vif->ar;
615 struct cfg80211_bss *bss;
616 u16 cap_mask, cap_val;
617 u8 *ie;
618
619 if (nw_type & ADHOC_NETWORK) {
620 cap_mask = WLAN_CAPABILITY_IBSS;
621 cap_val = WLAN_CAPABILITY_IBSS;
622 } else {
623 cap_mask = WLAN_CAPABILITY_ESS;
624 cap_val = WLAN_CAPABILITY_ESS;
625 }
626
627 bss = cfg80211_get_bss(ar->wiphy, chan, bssid,
628 vif->ssid, vif->ssid_len,
629 cap_mask, cap_val);
630 if (bss == NULL) {
631 /*
632 * Since cfg80211 may not yet know about the BSS,
633 * generate a partial entry until the first BSS info
634 * event becomes available.
635 *
636 * Prepend SSID element since it is not included in the Beacon
637 * IEs from the target.
638 */
639 ie = kmalloc(2 + vif->ssid_len + beacon_ie_len, GFP_KERNEL);
640 if (ie == NULL)
641 return -ENOMEM;
642 ie[0] = WLAN_EID_SSID;
643 ie[1] = vif->ssid_len;
644 memcpy(ie + 2, vif->ssid, vif->ssid_len);
645 memcpy(ie + 2 + vif->ssid_len, beacon_ie, beacon_ie_len);
646 bss = cfg80211_inform_bss(ar->wiphy, chan,
647 bssid, 0, cap_val, 100,
648 ie, 2 + vif->ssid_len + beacon_ie_len,
649 0, GFP_KERNEL);
650 if (bss)
651 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "added bss %pM to "
652 "cfg80211\n", bssid);
653 kfree(ie);
654 } else
655 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "cfg80211 already has a bss "
656 "entry\n");
657
658 if (bss == NULL)
659 return -ENOMEM;
660
661 cfg80211_put_bss(bss);
662
663 return 0;
664 }
665
666 void ath6kl_cfg80211_connect_event(struct ath6kl_vif *vif, u16 channel,
667 u8 *bssid, u16 listen_intvl,
668 u16 beacon_intvl,
669 enum network_type nw_type,
670 u8 beacon_ie_len, u8 assoc_req_len,
671 u8 assoc_resp_len, u8 *assoc_info)
672 {
673 struct ieee80211_channel *chan;
674 struct ath6kl *ar = vif->ar;
675
676 /* capinfo + listen interval */
677 u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16);
678
679 /* capinfo + status code + associd */
680 u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16);
681
682 u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset;
683 u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len +
684 assoc_resp_ie_offset;
685
686 assoc_req_len -= assoc_req_ie_offset;
687 assoc_resp_len -= assoc_resp_ie_offset;
688
689 /*
690 * Store Beacon interval here; DTIM period will be available only once
691 * a Beacon frame from the AP is seen.
692 */
693 vif->assoc_bss_beacon_int = beacon_intvl;
694 clear_bit(DTIM_PERIOD_AVAIL, &vif->flags);
695
696 if (nw_type & ADHOC_NETWORK) {
697 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) {
698 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
699 "%s: ath6k not in ibss mode\n", __func__);
700 return;
701 }
702 }
703
704 if (nw_type & INFRA_NETWORK) {
705 if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
706 vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
707 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
708 "%s: ath6k not in station mode\n", __func__);
709 return;
710 }
711 }
712
713 chan = ieee80211_get_channel(ar->wiphy, (int) channel);
714
715 if (ath6kl_add_bss_if_needed(vif, nw_type, bssid, chan, assoc_info,
716 beacon_ie_len) < 0) {
717 ath6kl_err("could not add cfg80211 bss entry\n");
718 return;
719 }
720
721 if (nw_type & ADHOC_NETWORK) {
722 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "ad-hoc %s selected\n",
723 nw_type & ADHOC_CREATOR ? "creator" : "joiner");
724 cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL);
725 return;
726 }
727
728 if (vif->sme_state == SME_CONNECTING) {
729 /* inform connect result to cfg80211 */
730 vif->sme_state = SME_CONNECTED;
731 cfg80211_connect_result(vif->ndev, bssid,
732 assoc_req_ie, assoc_req_len,
733 assoc_resp_ie, assoc_resp_len,
734 WLAN_STATUS_SUCCESS, GFP_KERNEL);
735 } else if (vif->sme_state == SME_CONNECTED) {
736 /* inform roam event to cfg80211 */
737 cfg80211_roamed(vif->ndev, chan, bssid,
738 assoc_req_ie, assoc_req_len,
739 assoc_resp_ie, assoc_resp_len, GFP_KERNEL);
740 }
741 }
742
743 static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy,
744 struct net_device *dev, u16 reason_code)
745 {
746 struct ath6kl *ar = ath6kl_priv(dev);
747 struct ath6kl_vif *vif = netdev_priv(dev);
748
749 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__,
750 reason_code);
751
752 ath6kl_cfg80211_sscan_disable(vif);
753
754 if (!ath6kl_cfg80211_ready(vif))
755 return -EIO;
756
757 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
758 ath6kl_err("busy, destroy in progress\n");
759 return -EBUSY;
760 }
761
762 if (down_interruptible(&ar->sem)) {
763 ath6kl_err("busy, couldn't get access\n");
764 return -ERESTARTSYS;
765 }
766
767 vif->reconnect_flag = 0;
768 ath6kl_disconnect(vif);
769 memset(vif->ssid, 0, sizeof(vif->ssid));
770 vif->ssid_len = 0;
771
772 if (!test_bit(SKIP_SCAN, &ar->flag))
773 memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
774
775 up(&ar->sem);
776
777 vif->sme_state = SME_DISCONNECTED;
778
779 return 0;
780 }
781
782 void ath6kl_cfg80211_disconnect_event(struct ath6kl_vif *vif, u8 reason,
783 u8 *bssid, u8 assoc_resp_len,
784 u8 *assoc_info, u16 proto_reason)
785 {
786 struct ath6kl *ar = vif->ar;
787
788 if (vif->scan_req) {
789 cfg80211_scan_done(vif->scan_req, true);
790 vif->scan_req = NULL;
791 }
792
793 if (vif->nw_type & ADHOC_NETWORK) {
794 if (vif->wdev.iftype != NL80211_IFTYPE_ADHOC) {
795 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
796 "%s: ath6k not in ibss mode\n", __func__);
797 return;
798 }
799 memset(bssid, 0, ETH_ALEN);
800 cfg80211_ibss_joined(vif->ndev, bssid, GFP_KERNEL);
801 return;
802 }
803
804 if (vif->nw_type & INFRA_NETWORK) {
805 if (vif->wdev.iftype != NL80211_IFTYPE_STATION &&
806 vif->wdev.iftype != NL80211_IFTYPE_P2P_CLIENT) {
807 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
808 "%s: ath6k not in station mode\n", __func__);
809 return;
810 }
811 }
812
813 /*
814 * Send a disconnect command to target when a disconnect event is
815 * received with reason code other than 3 (DISCONNECT_CMD - disconnect
816 * request from host) to make the firmware stop trying to connect even
817 * after giving disconnect event. There will be one more disconnect
818 * event for this disconnect command with reason code DISCONNECT_CMD
819 * which will be notified to cfg80211.
820 */
821
822 if (reason != DISCONNECT_CMD) {
823 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
824 return;
825 }
826
827 clear_bit(CONNECT_PEND, &vif->flags);
828
829 if (vif->sme_state == SME_CONNECTING) {
830 cfg80211_connect_result(vif->ndev,
831 bssid, NULL, 0,
832 NULL, 0,
833 WLAN_STATUS_UNSPECIFIED_FAILURE,
834 GFP_KERNEL);
835 } else if (vif->sme_state == SME_CONNECTED) {
836 cfg80211_disconnected(vif->ndev, reason,
837 NULL, 0, GFP_KERNEL);
838 }
839
840 vif->sme_state = SME_DISCONNECTED;
841 }
842
843 static int ath6kl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
844 struct cfg80211_scan_request *request)
845 {
846 struct ath6kl *ar = ath6kl_priv(ndev);
847 struct ath6kl_vif *vif = netdev_priv(ndev);
848 s8 n_channels = 0;
849 u16 *channels = NULL;
850 int ret = 0;
851 u32 force_fg_scan = 0;
852
853 if (!ath6kl_cfg80211_ready(vif))
854 return -EIO;
855
856 ath6kl_cfg80211_sscan_disable(vif);
857
858 if (!ar->usr_bss_filter) {
859 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &vif->flags);
860 ret = ath6kl_wmi_bssfilter_cmd(
861 ar->wmi, vif->fw_vif_idx,
862 (test_bit(CONNECTED, &vif->flags) ?
863 ALL_BUT_BSS_FILTER : ALL_BSS_FILTER), 0);
864 if (ret) {
865 ath6kl_err("couldn't set bss filtering\n");
866 return ret;
867 }
868 }
869
870 if (request->n_ssids && request->ssids[0].ssid_len) {
871 u8 i;
872
873 if (request->n_ssids > (MAX_PROBED_SSID_INDEX - 1))
874 request->n_ssids = MAX_PROBED_SSID_INDEX - 1;
875
876 for (i = 0; i < request->n_ssids; i++)
877 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx,
878 i + 1, SPECIFIC_SSID_FLAG,
879 request->ssids[i].ssid_len,
880 request->ssids[i].ssid);
881 }
882
883 /*
884 * FIXME: we should clear the IE in fw if it's not set so just
885 * remove the check altogether
886 */
887 if (request->ie) {
888 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
889 WMI_FRAME_PROBE_REQ,
890 request->ie, request->ie_len);
891 if (ret) {
892 ath6kl_err("failed to set Probe Request appie for "
893 "scan");
894 return ret;
895 }
896 }
897
898 /*
899 * Scan only the requested channels if the request specifies a set of
900 * channels. If the list is longer than the target supports, do not
901 * configure the list and instead, scan all available channels.
902 */
903 if (request->n_channels > 0 &&
904 request->n_channels <= WMI_MAX_CHANNELS) {
905 u8 i;
906
907 n_channels = request->n_channels;
908
909 channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL);
910 if (channels == NULL) {
911 ath6kl_warn("failed to set scan channels, "
912 "scan all channels");
913 n_channels = 0;
914 }
915
916 for (i = 0; i < n_channels; i++)
917 channels[i] = request->channels[i]->center_freq;
918 }
919
920 if (test_bit(CONNECTED, &vif->flags))
921 force_fg_scan = 1;
922
923 if (test_bit(ATH6KL_FW_CAPABILITY_STA_P2PDEV_DUPLEX,
924 ar->fw_capabilities)) {
925 /*
926 * If capable of doing P2P mgmt operations using
927 * station interface, send additional information like
928 * supported rates to advertise and xmit rates for
929 * probe requests
930 */
931 ret = ath6kl_wmi_beginscan_cmd(ar->wmi, vif->fw_vif_idx,
932 WMI_LONG_SCAN, force_fg_scan,
933 false, 0, 0, n_channels,
934 channels, request->no_cck,
935 request->rates);
936 } else {
937 ret = ath6kl_wmi_startscan_cmd(ar->wmi, vif->fw_vif_idx,
938 WMI_LONG_SCAN, force_fg_scan,
939 false, 0, 0, n_channels,
940 channels);
941 }
942 if (ret)
943 ath6kl_err("wmi_startscan_cmd failed\n");
944 else
945 vif->scan_req = request;
946
947 kfree(channels);
948
949 return ret;
950 }
951
952 void ath6kl_cfg80211_scan_complete_event(struct ath6kl_vif *vif, bool aborted)
953 {
954 struct ath6kl *ar = vif->ar;
955 int i;
956
957 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status%s\n", __func__,
958 aborted ? " aborted" : "");
959
960 if (!vif->scan_req)
961 return;
962
963 if (aborted)
964 goto out;
965
966 if (vif->scan_req->n_ssids && vif->scan_req->ssids[0].ssid_len) {
967 for (i = 0; i < vif->scan_req->n_ssids; i++) {
968 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx,
969 i + 1, DISABLE_SSID_FLAG,
970 0, NULL);
971 }
972 }
973
974 out:
975 cfg80211_scan_done(vif->scan_req, aborted);
976 vif->scan_req = NULL;
977 }
978
979 static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
980 u8 key_index, bool pairwise,
981 const u8 *mac_addr,
982 struct key_params *params)
983 {
984 struct ath6kl *ar = ath6kl_priv(ndev);
985 struct ath6kl_vif *vif = netdev_priv(ndev);
986 struct ath6kl_key *key = NULL;
987 u8 key_usage;
988 u8 key_type;
989
990 if (!ath6kl_cfg80211_ready(vif))
991 return -EIO;
992
993 if (params->cipher == CCKM_KRK_CIPHER_SUITE) {
994 if (params->key_len != WMI_KRK_LEN)
995 return -EINVAL;
996 return ath6kl_wmi_add_krk_cmd(ar->wmi, vif->fw_vif_idx,
997 params->key);
998 }
999
1000 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
1001 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1002 "%s: key index %d out of bounds\n", __func__,
1003 key_index);
1004 return -ENOENT;
1005 }
1006
1007 key = &vif->keys[key_index];
1008 memset(key, 0, sizeof(struct ath6kl_key));
1009
1010 if (pairwise)
1011 key_usage = PAIRWISE_USAGE;
1012 else
1013 key_usage = GROUP_USAGE;
1014
1015 if (params) {
1016 int seq_len = params->seq_len;
1017 if (params->cipher == WLAN_CIPHER_SUITE_SMS4 &&
1018 seq_len > ATH6KL_KEY_SEQ_LEN) {
1019 /* Only first half of the WPI PN is configured */
1020 seq_len = ATH6KL_KEY_SEQ_LEN;
1021 }
1022 if (params->key_len > WLAN_MAX_KEY_LEN ||
1023 seq_len > sizeof(key->seq))
1024 return -EINVAL;
1025
1026 key->key_len = params->key_len;
1027 memcpy(key->key, params->key, key->key_len);
1028 key->seq_len = seq_len;
1029 memcpy(key->seq, params->seq, key->seq_len);
1030 key->cipher = params->cipher;
1031 }
1032
1033 switch (key->cipher) {
1034 case WLAN_CIPHER_SUITE_WEP40:
1035 case WLAN_CIPHER_SUITE_WEP104:
1036 key_type = WEP_CRYPT;
1037 break;
1038
1039 case WLAN_CIPHER_SUITE_TKIP:
1040 key_type = TKIP_CRYPT;
1041 break;
1042
1043 case WLAN_CIPHER_SUITE_CCMP:
1044 key_type = AES_CRYPT;
1045 break;
1046 case WLAN_CIPHER_SUITE_SMS4:
1047 key_type = WAPI_CRYPT;
1048 break;
1049
1050 default:
1051 return -ENOTSUPP;
1052 }
1053
1054 if (((vif->auth_mode == WPA_PSK_AUTH)
1055 || (vif->auth_mode == WPA2_PSK_AUTH))
1056 && (key_usage & GROUP_USAGE))
1057 del_timer(&vif->disconnect_timer);
1058
1059 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1060 "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n",
1061 __func__, key_index, key->key_len, key_type,
1062 key_usage, key->seq_len);
1063
1064 if (vif->nw_type == AP_NETWORK && !pairwise &&
1065 (key_type == TKIP_CRYPT || key_type == AES_CRYPT ||
1066 key_type == WAPI_CRYPT) && params) {
1067 ar->ap_mode_bkey.valid = true;
1068 ar->ap_mode_bkey.key_index = key_index;
1069 ar->ap_mode_bkey.key_type = key_type;
1070 ar->ap_mode_bkey.key_len = key->key_len;
1071 memcpy(ar->ap_mode_bkey.key, key->key, key->key_len);
1072 if (!test_bit(CONNECTED, &vif->flags)) {
1073 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "Delay initial group "
1074 "key configuration until AP mode has been "
1075 "started\n");
1076 /*
1077 * The key will be set in ath6kl_connect_ap_mode() once
1078 * the connected event is received from the target.
1079 */
1080 return 0;
1081 }
1082 }
1083
1084 if (vif->next_mode == AP_NETWORK && key_type == WEP_CRYPT &&
1085 !test_bit(CONNECTED, &vif->flags)) {
1086 /*
1087 * Store the key locally so that it can be re-configured after
1088 * the AP mode has properly started
1089 * (ath6kl_install_statioc_wep_keys).
1090 */
1091 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "Delay WEP key configuration "
1092 "until AP mode has been started\n");
1093 vif->wep_key_list[key_index].key_len = key->key_len;
1094 memcpy(vif->wep_key_list[key_index].key, key->key,
1095 key->key_len);
1096 return 0;
1097 }
1098
1099 return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx, key_index,
1100 key_type, key_usage, key->key_len,
1101 key->seq, key->seq_len, key->key,
1102 KEY_OP_INIT_VAL,
1103 (u8 *) mac_addr, SYNC_BOTH_WMIFLAG);
1104 }
1105
1106 static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
1107 u8 key_index, bool pairwise,
1108 const u8 *mac_addr)
1109 {
1110 struct ath6kl *ar = ath6kl_priv(ndev);
1111 struct ath6kl_vif *vif = netdev_priv(ndev);
1112
1113 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1114
1115 if (!ath6kl_cfg80211_ready(vif))
1116 return -EIO;
1117
1118 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
1119 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1120 "%s: key index %d out of bounds\n", __func__,
1121 key_index);
1122 return -ENOENT;
1123 }
1124
1125 if (!vif->keys[key_index].key_len) {
1126 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1127 "%s: index %d is empty\n", __func__, key_index);
1128 return 0;
1129 }
1130
1131 vif->keys[key_index].key_len = 0;
1132
1133 return ath6kl_wmi_deletekey_cmd(ar->wmi, vif->fw_vif_idx, key_index);
1134 }
1135
1136 static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
1137 u8 key_index, bool pairwise,
1138 const u8 *mac_addr, void *cookie,
1139 void (*callback) (void *cookie,
1140 struct key_params *))
1141 {
1142 struct ath6kl_vif *vif = netdev_priv(ndev);
1143 struct ath6kl_key *key = NULL;
1144 struct key_params params;
1145
1146 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1147
1148 if (!ath6kl_cfg80211_ready(vif))
1149 return -EIO;
1150
1151 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
1152 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1153 "%s: key index %d out of bounds\n", __func__,
1154 key_index);
1155 return -ENOENT;
1156 }
1157
1158 key = &vif->keys[key_index];
1159 memset(&params, 0, sizeof(params));
1160 params.cipher = key->cipher;
1161 params.key_len = key->key_len;
1162 params.seq_len = key->seq_len;
1163 params.seq = key->seq;
1164 params.key = key->key;
1165
1166 callback(cookie, &params);
1167
1168 return key->key_len ? 0 : -ENOENT;
1169 }
1170
1171 static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy,
1172 struct net_device *ndev,
1173 u8 key_index, bool unicast,
1174 bool multicast)
1175 {
1176 struct ath6kl *ar = ath6kl_priv(ndev);
1177 struct ath6kl_vif *vif = netdev_priv(ndev);
1178 struct ath6kl_key *key = NULL;
1179 u8 key_usage;
1180 enum crypto_type key_type = NONE_CRYPT;
1181
1182 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1183
1184 if (!ath6kl_cfg80211_ready(vif))
1185 return -EIO;
1186
1187 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
1188 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1189 "%s: key index %d out of bounds\n",
1190 __func__, key_index);
1191 return -ENOENT;
1192 }
1193
1194 if (!vif->keys[key_index].key_len) {
1195 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n",
1196 __func__, key_index);
1197 return -EINVAL;
1198 }
1199
1200 vif->def_txkey_index = key_index;
1201 key = &vif->keys[vif->def_txkey_index];
1202 key_usage = GROUP_USAGE;
1203 if (vif->prwise_crypto == WEP_CRYPT)
1204 key_usage |= TX_USAGE;
1205 if (unicast)
1206 key_type = vif->prwise_crypto;
1207 if (multicast)
1208 key_type = vif->grp_crypto;
1209
1210 if (vif->next_mode == AP_NETWORK && !test_bit(CONNECTED, &vif->flags))
1211 return 0; /* Delay until AP mode has been started */
1212
1213 return ath6kl_wmi_addkey_cmd(ar->wmi, vif->fw_vif_idx,
1214 vif->def_txkey_index,
1215 key_type, key_usage,
1216 key->key_len, key->seq, key->seq_len,
1217 key->key,
1218 KEY_OP_INIT_VAL, NULL,
1219 SYNC_BOTH_WMIFLAG);
1220 }
1221
1222 void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl_vif *vif, u8 keyid,
1223 bool ismcast)
1224 {
1225 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1226 "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast);
1227
1228 cfg80211_michael_mic_failure(vif->ndev, vif->bssid,
1229 (ismcast ? NL80211_KEYTYPE_GROUP :
1230 NL80211_KEYTYPE_PAIRWISE), keyid, NULL,
1231 GFP_KERNEL);
1232 }
1233
1234 static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1235 {
1236 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1237 struct ath6kl_vif *vif;
1238 int ret;
1239
1240 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__,
1241 changed);
1242
1243 vif = ath6kl_vif_first(ar);
1244 if (!vif)
1245 return -EIO;
1246
1247 if (!ath6kl_cfg80211_ready(vif))
1248 return -EIO;
1249
1250 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1251 ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold);
1252 if (ret != 0) {
1253 ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n");
1254 return -EIO;
1255 }
1256 }
1257
1258 return 0;
1259 }
1260
1261 /*
1262 * The type nl80211_tx_power_setting replaces the following
1263 * data type from 2.6.36 onwards
1264 */
1265 static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy,
1266 enum nl80211_tx_power_setting type,
1267 int mbm)
1268 {
1269 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1270 struct ath6kl_vif *vif;
1271 u8 ath6kl_dbm;
1272 int dbm = MBM_TO_DBM(mbm);
1273
1274 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__,
1275 type, dbm);
1276
1277 vif = ath6kl_vif_first(ar);
1278 if (!vif)
1279 return -EIO;
1280
1281 if (!ath6kl_cfg80211_ready(vif))
1282 return -EIO;
1283
1284 switch (type) {
1285 case NL80211_TX_POWER_AUTOMATIC:
1286 return 0;
1287 case NL80211_TX_POWER_LIMITED:
1288 ar->tx_pwr = ath6kl_dbm = dbm;
1289 break;
1290 default:
1291 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n",
1292 __func__, type);
1293 return -EOPNOTSUPP;
1294 }
1295
1296 ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx, ath6kl_dbm);
1297
1298 return 0;
1299 }
1300
1301 static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm)
1302 {
1303 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1304 struct ath6kl_vif *vif;
1305
1306 vif = ath6kl_vif_first(ar);
1307 if (!vif)
1308 return -EIO;
1309
1310 if (!ath6kl_cfg80211_ready(vif))
1311 return -EIO;
1312
1313 if (test_bit(CONNECTED, &vif->flags)) {
1314 ar->tx_pwr = 0;
1315
1316 if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi, vif->fw_vif_idx) != 0) {
1317 ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n");
1318 return -EIO;
1319 }
1320
1321 wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 0,
1322 5 * HZ);
1323
1324 if (signal_pending(current)) {
1325 ath6kl_err("target did not respond\n");
1326 return -EINTR;
1327 }
1328 }
1329
1330 *dbm = ar->tx_pwr;
1331 return 0;
1332 }
1333
1334 static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
1335 struct net_device *dev,
1336 bool pmgmt, int timeout)
1337 {
1338 struct ath6kl *ar = ath6kl_priv(dev);
1339 struct wmi_power_mode_cmd mode;
1340 struct ath6kl_vif *vif = netdev_priv(dev);
1341
1342 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n",
1343 __func__, pmgmt, timeout);
1344
1345 if (!ath6kl_cfg80211_ready(vif))
1346 return -EIO;
1347
1348 if (pmgmt) {
1349 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__);
1350 mode.pwr_mode = REC_POWER;
1351 } else {
1352 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__);
1353 mode.pwr_mode = MAX_PERF_POWER;
1354 }
1355
1356 if (ath6kl_wmi_powermode_cmd(ar->wmi, vif->fw_vif_idx,
1357 mode.pwr_mode) != 0) {
1358 ath6kl_err("wmi_powermode_cmd failed\n");
1359 return -EIO;
1360 }
1361
1362 return 0;
1363 }
1364
1365 static struct net_device *ath6kl_cfg80211_add_iface(struct wiphy *wiphy,
1366 char *name,
1367 enum nl80211_iftype type,
1368 u32 *flags,
1369 struct vif_params *params)
1370 {
1371 struct ath6kl *ar = wiphy_priv(wiphy);
1372 struct net_device *ndev;
1373 u8 if_idx, nw_type;
1374
1375 if (ar->num_vif == ar->vif_max) {
1376 ath6kl_err("Reached maximum number of supported vif\n");
1377 return ERR_PTR(-EINVAL);
1378 }
1379
1380 if (!ath6kl_is_valid_iftype(ar, type, &if_idx, &nw_type)) {
1381 ath6kl_err("Not a supported interface type\n");
1382 return ERR_PTR(-EINVAL);
1383 }
1384
1385 ndev = ath6kl_interface_add(ar, name, type, if_idx, nw_type);
1386 if (!ndev)
1387 return ERR_PTR(-ENOMEM);
1388
1389 ar->num_vif++;
1390
1391 return ndev;
1392 }
1393
1394 static int ath6kl_cfg80211_del_iface(struct wiphy *wiphy,
1395 struct net_device *ndev)
1396 {
1397 struct ath6kl *ar = wiphy_priv(wiphy);
1398 struct ath6kl_vif *vif = netdev_priv(ndev);
1399
1400 spin_lock_bh(&ar->list_lock);
1401 list_del(&vif->list);
1402 spin_unlock_bh(&ar->list_lock);
1403
1404 ath6kl_cleanup_vif(vif, test_bit(WMI_READY, &ar->flag));
1405
1406 ath6kl_deinit_if_data(vif);
1407
1408 return 0;
1409 }
1410
1411 static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy,
1412 struct net_device *ndev,
1413 enum nl80211_iftype type, u32 *flags,
1414 struct vif_params *params)
1415 {
1416 struct ath6kl_vif *vif = netdev_priv(ndev);
1417
1418 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type);
1419
1420 switch (type) {
1421 case NL80211_IFTYPE_STATION:
1422 vif->next_mode = INFRA_NETWORK;
1423 break;
1424 case NL80211_IFTYPE_ADHOC:
1425 vif->next_mode = ADHOC_NETWORK;
1426 break;
1427 case NL80211_IFTYPE_AP:
1428 vif->next_mode = AP_NETWORK;
1429 break;
1430 case NL80211_IFTYPE_P2P_CLIENT:
1431 vif->next_mode = INFRA_NETWORK;
1432 break;
1433 case NL80211_IFTYPE_P2P_GO:
1434 vif->next_mode = AP_NETWORK;
1435 break;
1436 default:
1437 ath6kl_err("invalid interface type %u\n", type);
1438 return -EOPNOTSUPP;
1439 }
1440
1441 vif->wdev.iftype = type;
1442
1443 return 0;
1444 }
1445
1446 static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy,
1447 struct net_device *dev,
1448 struct cfg80211_ibss_params *ibss_param)
1449 {
1450 struct ath6kl *ar = ath6kl_priv(dev);
1451 struct ath6kl_vif *vif = netdev_priv(dev);
1452 int status;
1453
1454 if (!ath6kl_cfg80211_ready(vif))
1455 return -EIO;
1456
1457 vif->ssid_len = ibss_param->ssid_len;
1458 memcpy(vif->ssid, ibss_param->ssid, vif->ssid_len);
1459
1460 if (ibss_param->channel)
1461 vif->ch_hint = ibss_param->channel->center_freq;
1462
1463 if (ibss_param->channel_fixed) {
1464 /*
1465 * TODO: channel_fixed: The channel should be fixed, do not
1466 * search for IBSSs to join on other channels. Target
1467 * firmware does not support this feature, needs to be
1468 * updated.
1469 */
1470 return -EOPNOTSUPP;
1471 }
1472
1473 memset(vif->req_bssid, 0, sizeof(vif->req_bssid));
1474 if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid))
1475 memcpy(vif->req_bssid, ibss_param->bssid,
1476 sizeof(vif->req_bssid));
1477
1478 ath6kl_set_wpa_version(vif, 0);
1479
1480 status = ath6kl_set_auth_type(vif, NL80211_AUTHTYPE_OPEN_SYSTEM);
1481 if (status)
1482 return status;
1483
1484 if (ibss_param->privacy) {
1485 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, true);
1486 ath6kl_set_cipher(vif, WLAN_CIPHER_SUITE_WEP40, false);
1487 } else {
1488 ath6kl_set_cipher(vif, 0, true);
1489 ath6kl_set_cipher(vif, 0, false);
1490 }
1491
1492 vif->nw_type = vif->next_mode;
1493
1494 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1495 "%s: connect called with authmode %d dot11 auth %d"
1496 " PW crypto %d PW crypto len %d GRP crypto %d"
1497 " GRP crypto len %d channel hint %u\n",
1498 __func__,
1499 vif->auth_mode, vif->dot11_auth_mode, vif->prwise_crypto,
1500 vif->prwise_crypto_len, vif->grp_crypto,
1501 vif->grp_crypto_len, vif->ch_hint);
1502
1503 status = ath6kl_wmi_connect_cmd(ar->wmi, vif->fw_vif_idx, vif->nw_type,
1504 vif->dot11_auth_mode, vif->auth_mode,
1505 vif->prwise_crypto,
1506 vif->prwise_crypto_len,
1507 vif->grp_crypto, vif->grp_crypto_len,
1508 vif->ssid_len, vif->ssid,
1509 vif->req_bssid, vif->ch_hint,
1510 ar->connect_ctrl_flags, SUBTYPE_NONE);
1511 set_bit(CONNECT_PEND, &vif->flags);
1512
1513 return 0;
1514 }
1515
1516 static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy,
1517 struct net_device *dev)
1518 {
1519 struct ath6kl_vif *vif = netdev_priv(dev);
1520
1521 if (!ath6kl_cfg80211_ready(vif))
1522 return -EIO;
1523
1524 ath6kl_disconnect(vif);
1525 memset(vif->ssid, 0, sizeof(vif->ssid));
1526 vif->ssid_len = 0;
1527
1528 return 0;
1529 }
1530
1531 static const u32 cipher_suites[] = {
1532 WLAN_CIPHER_SUITE_WEP40,
1533 WLAN_CIPHER_SUITE_WEP104,
1534 WLAN_CIPHER_SUITE_TKIP,
1535 WLAN_CIPHER_SUITE_CCMP,
1536 CCKM_KRK_CIPHER_SUITE,
1537 WLAN_CIPHER_SUITE_SMS4,
1538 };
1539
1540 static bool is_rate_legacy(s32 rate)
1541 {
1542 static const s32 legacy[] = { 1000, 2000, 5500, 11000,
1543 6000, 9000, 12000, 18000, 24000,
1544 36000, 48000, 54000
1545 };
1546 u8 i;
1547
1548 for (i = 0; i < ARRAY_SIZE(legacy); i++)
1549 if (rate == legacy[i])
1550 return true;
1551
1552 return false;
1553 }
1554
1555 static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
1556 {
1557 static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
1558 52000, 58500, 65000, 72200
1559 };
1560 u8 i;
1561
1562 for (i = 0; i < ARRAY_SIZE(ht20); i++) {
1563 if (rate == ht20[i]) {
1564 if (i == ARRAY_SIZE(ht20) - 1)
1565 /* last rate uses sgi */
1566 *sgi = true;
1567 else
1568 *sgi = false;
1569
1570 *mcs = i;
1571 return true;
1572 }
1573 }
1574 return false;
1575 }
1576
1577 static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
1578 {
1579 static const s32 ht40[] = { 13500, 27000, 40500, 54000,
1580 81000, 108000, 121500, 135000,
1581 150000
1582 };
1583 u8 i;
1584
1585 for (i = 0; i < ARRAY_SIZE(ht40); i++) {
1586 if (rate == ht40[i]) {
1587 if (i == ARRAY_SIZE(ht40) - 1)
1588 /* last rate uses sgi */
1589 *sgi = true;
1590 else
1591 *sgi = false;
1592
1593 *mcs = i;
1594 return true;
1595 }
1596 }
1597
1598 return false;
1599 }
1600
1601 static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev,
1602 u8 *mac, struct station_info *sinfo)
1603 {
1604 struct ath6kl *ar = ath6kl_priv(dev);
1605 struct ath6kl_vif *vif = netdev_priv(dev);
1606 long left;
1607 bool sgi;
1608 s32 rate;
1609 int ret;
1610 u8 mcs;
1611
1612 if (memcmp(mac, vif->bssid, ETH_ALEN) != 0)
1613 return -ENOENT;
1614
1615 if (down_interruptible(&ar->sem))
1616 return -EBUSY;
1617
1618 set_bit(STATS_UPDATE_PEND, &vif->flags);
1619
1620 ret = ath6kl_wmi_get_stats_cmd(ar->wmi, vif->fw_vif_idx);
1621
1622 if (ret != 0) {
1623 up(&ar->sem);
1624 return -EIO;
1625 }
1626
1627 left = wait_event_interruptible_timeout(ar->event_wq,
1628 !test_bit(STATS_UPDATE_PEND,
1629 &vif->flags),
1630 WMI_TIMEOUT);
1631
1632 up(&ar->sem);
1633
1634 if (left == 0)
1635 return -ETIMEDOUT;
1636 else if (left < 0)
1637 return left;
1638
1639 if (vif->target_stats.rx_byte) {
1640 sinfo->rx_bytes = vif->target_stats.rx_byte;
1641 sinfo->filled |= STATION_INFO_RX_BYTES;
1642 sinfo->rx_packets = vif->target_stats.rx_pkt;
1643 sinfo->filled |= STATION_INFO_RX_PACKETS;
1644 }
1645
1646 if (vif->target_stats.tx_byte) {
1647 sinfo->tx_bytes = vif->target_stats.tx_byte;
1648 sinfo->filled |= STATION_INFO_TX_BYTES;
1649 sinfo->tx_packets = vif->target_stats.tx_pkt;
1650 sinfo->filled |= STATION_INFO_TX_PACKETS;
1651 }
1652
1653 sinfo->signal = vif->target_stats.cs_rssi;
1654 sinfo->filled |= STATION_INFO_SIGNAL;
1655
1656 rate = vif->target_stats.tx_ucast_rate;
1657
1658 if (is_rate_legacy(rate)) {
1659 sinfo->txrate.legacy = rate / 100;
1660 } else if (is_rate_ht20(rate, &mcs, &sgi)) {
1661 if (sgi) {
1662 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1663 sinfo->txrate.mcs = mcs - 1;
1664 } else {
1665 sinfo->txrate.mcs = mcs;
1666 }
1667
1668 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1669 } else if (is_rate_ht40(rate, &mcs, &sgi)) {
1670 if (sgi) {
1671 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1672 sinfo->txrate.mcs = mcs - 1;
1673 } else {
1674 sinfo->txrate.mcs = mcs;
1675 }
1676
1677 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
1678 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1679 } else {
1680 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1681 "invalid rate from stats: %d\n", rate);
1682 ath6kl_debug_war(ar, ATH6KL_WAR_INVALID_RATE);
1683 return 0;
1684 }
1685
1686 sinfo->filled |= STATION_INFO_TX_BITRATE;
1687
1688 if (test_bit(CONNECTED, &vif->flags) &&
1689 test_bit(DTIM_PERIOD_AVAIL, &vif->flags) &&
1690 vif->nw_type == INFRA_NETWORK) {
1691 sinfo->filled |= STATION_INFO_BSS_PARAM;
1692 sinfo->bss_param.flags = 0;
1693 sinfo->bss_param.dtim_period = vif->assoc_bss_dtim_period;
1694 sinfo->bss_param.beacon_interval = vif->assoc_bss_beacon_int;
1695 }
1696
1697 return 0;
1698 }
1699
1700 static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1701 struct cfg80211_pmksa *pmksa)
1702 {
1703 struct ath6kl *ar = ath6kl_priv(netdev);
1704 struct ath6kl_vif *vif = netdev_priv(netdev);
1705
1706 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1707 pmksa->pmkid, true);
1708 }
1709
1710 static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1711 struct cfg80211_pmksa *pmksa)
1712 {
1713 struct ath6kl *ar = ath6kl_priv(netdev);
1714 struct ath6kl_vif *vif = netdev_priv(netdev);
1715
1716 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx, pmksa->bssid,
1717 pmksa->pmkid, false);
1718 }
1719
1720 static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1721 {
1722 struct ath6kl *ar = ath6kl_priv(netdev);
1723 struct ath6kl_vif *vif = netdev_priv(netdev);
1724
1725 if (test_bit(CONNECTED, &vif->flags))
1726 return ath6kl_wmi_setpmkid_cmd(ar->wmi, vif->fw_vif_idx,
1727 vif->bssid, NULL, false);
1728 return 0;
1729 }
1730
1731 static int ath6kl_wow_suspend(struct ath6kl *ar, struct cfg80211_wowlan *wow)
1732 {
1733 struct ath6kl_vif *vif;
1734 int ret, pos, left;
1735 u32 filter = 0;
1736 u16 i;
1737 u8 mask[WOW_MASK_SIZE];
1738
1739 vif = ath6kl_vif_first(ar);
1740 if (!vif)
1741 return -EIO;
1742
1743 if (!ath6kl_cfg80211_ready(vif))
1744 return -EIO;
1745
1746 if (!test_bit(CONNECTED, &vif->flags))
1747 return -EINVAL;
1748
1749 /* Clear existing WOW patterns */
1750 for (i = 0; i < WOW_MAX_FILTERS_PER_LIST; i++)
1751 ath6kl_wmi_del_wow_pattern_cmd(ar->wmi, vif->fw_vif_idx,
1752 WOW_LIST_ID, i);
1753 /* Configure new WOW patterns */
1754 for (i = 0; i < wow->n_patterns; i++) {
1755
1756 /*
1757 * Convert given nl80211 specific mask value to equivalent
1758 * driver specific mask value and send it to the chip along
1759 * with patterns. For example, If the mask value defined in
1760 * struct cfg80211_wowlan is 0xA (equivalent binary is 1010),
1761 * then equivalent driver specific mask value is
1762 * "0xFF 0x00 0xFF 0x00".
1763 */
1764 memset(&mask, 0, sizeof(mask));
1765 for (pos = 0; pos < wow->patterns[i].pattern_len; pos++) {
1766 if (wow->patterns[i].mask[pos / 8] & (0x1 << (pos % 8)))
1767 mask[pos] = 0xFF;
1768 }
1769 /*
1770 * Note: Pattern's offset is not passed as part of wowlan
1771 * parameter from CFG layer. So it's always passed as ZERO
1772 * to the firmware. It means, given WOW patterns are always
1773 * matched from the first byte of received pkt in the firmware.
1774 */
1775 ret = ath6kl_wmi_add_wow_pattern_cmd(ar->wmi,
1776 vif->fw_vif_idx, WOW_LIST_ID,
1777 wow->patterns[i].pattern_len,
1778 0 /* pattern offset */,
1779 wow->patterns[i].pattern, mask);
1780 if (ret)
1781 return ret;
1782 }
1783
1784 if (wow->disconnect)
1785 filter |= WOW_FILTER_OPTION_NWK_DISASSOC;
1786
1787 if (wow->magic_pkt)
1788 filter |= WOW_FILTER_OPTION_MAGIC_PACKET;
1789
1790 if (wow->gtk_rekey_failure)
1791 filter |= WOW_FILTER_OPTION_GTK_ERROR;
1792
1793 if (wow->eap_identity_req)
1794 filter |= WOW_FILTER_OPTION_EAP_REQ;
1795
1796 if (wow->four_way_handshake)
1797 filter |= WOW_FILTER_OPTION_8021X_4WAYHS;
1798
1799 ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx,
1800 ATH6KL_WOW_MODE_ENABLE,
1801 filter,
1802 WOW_HOST_REQ_DELAY);
1803 if (ret)
1804 return ret;
1805
1806 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
1807 ATH6KL_HOST_MODE_ASLEEP);
1808 if (ret)
1809 return ret;
1810
1811 if (ar->tx_pending[ar->ctrl_ep]) {
1812 left = wait_event_interruptible_timeout(ar->event_wq,
1813 ar->tx_pending[ar->ctrl_ep] == 0, WMI_TIMEOUT);
1814 if (left == 0) {
1815 ath6kl_warn("clear wmi ctrl data timeout\n");
1816 ret = -ETIMEDOUT;
1817 } else if (left < 0) {
1818 ath6kl_warn("clear wmi ctrl data failed: %d\n", left);
1819 ret = left;
1820 }
1821 }
1822
1823 return ret;
1824 }
1825
1826 static int ath6kl_wow_resume(struct ath6kl *ar)
1827 {
1828 struct ath6kl_vif *vif;
1829 int ret;
1830
1831 vif = ath6kl_vif_first(ar);
1832 if (!vif)
1833 return -EIO;
1834
1835 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
1836 ATH6KL_HOST_MODE_AWAKE);
1837 return ret;
1838 }
1839
1840 int ath6kl_cfg80211_suspend(struct ath6kl *ar,
1841 enum ath6kl_cfg_suspend_mode mode,
1842 struct cfg80211_wowlan *wow)
1843 {
1844 int ret;
1845
1846 switch (mode) {
1847 case ATH6KL_CFG_SUSPEND_WOW:
1848
1849 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode suspend\n");
1850
1851 /* Flush all non control pkts in TX path */
1852 ath6kl_tx_data_cleanup(ar);
1853
1854 ret = ath6kl_wow_suspend(ar, wow);
1855 if (ret) {
1856 ath6kl_err("wow suspend failed: %d\n", ret);
1857 return ret;
1858 }
1859 ar->state = ATH6KL_STATE_WOW;
1860 break;
1861
1862 case ATH6KL_CFG_SUSPEND_DEEPSLEEP:
1863
1864 ath6kl_cfg80211_stop_all(ar);
1865
1866 /* save the current power mode before enabling power save */
1867 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
1868
1869 ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER);
1870 if (ret) {
1871 ath6kl_warn("wmi powermode command failed during suspend: %d\n",
1872 ret);
1873 }
1874
1875 ar->state = ATH6KL_STATE_DEEPSLEEP;
1876
1877 break;
1878
1879 case ATH6KL_CFG_SUSPEND_CUTPOWER:
1880
1881 ath6kl_cfg80211_stop_all(ar);
1882
1883 if (ar->state == ATH6KL_STATE_OFF) {
1884 ath6kl_dbg(ATH6KL_DBG_SUSPEND,
1885 "suspend hw off, no action for cutpower\n");
1886 break;
1887 }
1888
1889 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "suspend cutting power\n");
1890
1891 ret = ath6kl_init_hw_stop(ar);
1892 if (ret) {
1893 ath6kl_warn("failed to stop hw during suspend: %d\n",
1894 ret);
1895 }
1896
1897 ar->state = ATH6KL_STATE_CUTPOWER;
1898
1899 break;
1900
1901 case ATH6KL_CFG_SUSPEND_SCHED_SCAN:
1902 /*
1903 * Nothing needed for schedule scan, firmware is already in
1904 * wow mode and sleeping most of the time.
1905 */
1906 break;
1907
1908 default:
1909 break;
1910 }
1911
1912 return 0;
1913 }
1914
1915 int ath6kl_cfg80211_resume(struct ath6kl *ar)
1916 {
1917 int ret;
1918
1919 switch (ar->state) {
1920 case ATH6KL_STATE_WOW:
1921 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "wow mode resume\n");
1922
1923 ret = ath6kl_wow_resume(ar);
1924 if (ret) {
1925 ath6kl_warn("wow mode resume failed: %d\n", ret);
1926 return ret;
1927 }
1928
1929 ar->state = ATH6KL_STATE_ON;
1930 break;
1931
1932 case ATH6KL_STATE_DEEPSLEEP:
1933 if (ar->wmi->pwr_mode != ar->wmi->saved_pwr_mode) {
1934 ret = ath6kl_wmi_powermode_cmd(ar->wmi, 0,
1935 ar->wmi->saved_pwr_mode);
1936 if (ret) {
1937 ath6kl_warn("wmi powermode command failed during resume: %d\n",
1938 ret);
1939 }
1940 }
1941
1942 ar->state = ATH6KL_STATE_ON;
1943
1944 break;
1945
1946 case ATH6KL_STATE_CUTPOWER:
1947 ath6kl_dbg(ATH6KL_DBG_SUSPEND, "resume restoring power\n");
1948
1949 ret = ath6kl_init_hw_start(ar);
1950 if (ret) {
1951 ath6kl_warn("Failed to boot hw in resume: %d\n", ret);
1952 return ret;
1953 }
1954 break;
1955
1956 case ATH6KL_STATE_SCHED_SCAN:
1957 break;
1958
1959 default:
1960 break;
1961 }
1962
1963 return 0;
1964 }
1965
1966 #ifdef CONFIG_PM
1967
1968 /* hif layer decides what suspend mode to use */
1969 static int __ath6kl_cfg80211_suspend(struct wiphy *wiphy,
1970 struct cfg80211_wowlan *wow)
1971 {
1972 struct ath6kl *ar = wiphy_priv(wiphy);
1973
1974 return ath6kl_hif_suspend(ar, wow);
1975 }
1976
1977 static int __ath6kl_cfg80211_resume(struct wiphy *wiphy)
1978 {
1979 struct ath6kl *ar = wiphy_priv(wiphy);
1980
1981 return ath6kl_hif_resume(ar);
1982 }
1983
1984 /*
1985 * FIXME: WOW suspend mode is selected if the host sdio controller supports
1986 * both sdio irq wake up and keep power. The target pulls sdio data line to
1987 * wake up the host when WOW pattern matches. This causes sdio irq handler
1988 * is being called in the host side which internally hits ath6kl's RX path.
1989 *
1990 * Since sdio interrupt is not disabled, RX path executes even before
1991 * the host executes the actual resume operation from PM module.
1992 *
1993 * In the current scenario, WOW resume should happen before start processing
1994 * any data from the target. So It's required to perform WOW resume in RX path.
1995 * Ideally we should perform WOW resume only in the actual platform
1996 * resume path. This area needs bit rework to avoid WOW resume in RX path.
1997 *
1998 * ath6kl_check_wow_status() is called from ath6kl_rx().
1999 */
2000 void ath6kl_check_wow_status(struct ath6kl *ar)
2001 {
2002 if (ar->state == ATH6KL_STATE_WOW)
2003 ath6kl_cfg80211_resume(ar);
2004 }
2005
2006 #else
2007
2008 void ath6kl_check_wow_status(struct ath6kl *ar)
2009 {
2010 }
2011 #endif
2012
2013 static int ath6kl_set_channel(struct wiphy *wiphy, struct net_device *dev,
2014 struct ieee80211_channel *chan,
2015 enum nl80211_channel_type channel_type)
2016 {
2017 struct ath6kl_vif *vif = netdev_priv(dev);
2018
2019 if (!ath6kl_cfg80211_ready(vif))
2020 return -EIO;
2021
2022 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: center_freq=%u hw_value=%u\n",
2023 __func__, chan->center_freq, chan->hw_value);
2024 vif->next_chan = chan->center_freq;
2025
2026 return 0;
2027 }
2028
2029 static bool ath6kl_is_p2p_ie(const u8 *pos)
2030 {
2031 return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
2032 pos[2] == 0x50 && pos[3] == 0x6f &&
2033 pos[4] == 0x9a && pos[5] == 0x09;
2034 }
2035
2036 static int ath6kl_set_ap_probe_resp_ies(struct ath6kl_vif *vif,
2037 const u8 *ies, size_t ies_len)
2038 {
2039 struct ath6kl *ar = vif->ar;
2040 const u8 *pos;
2041 u8 *buf = NULL;
2042 size_t len = 0;
2043 int ret;
2044
2045 /*
2046 * Filter out P2P IE(s) since they will be included depending on
2047 * the Probe Request frame in ath6kl_send_go_probe_resp().
2048 */
2049
2050 if (ies && ies_len) {
2051 buf = kmalloc(ies_len, GFP_KERNEL);
2052 if (buf == NULL)
2053 return -ENOMEM;
2054 pos = ies;
2055 while (pos + 1 < ies + ies_len) {
2056 if (pos + 2 + pos[1] > ies + ies_len)
2057 break;
2058 if (!ath6kl_is_p2p_ie(pos)) {
2059 memcpy(buf + len, pos, 2 + pos[1]);
2060 len += 2 + pos[1];
2061 }
2062 pos += 2 + pos[1];
2063 }
2064 }
2065
2066 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2067 WMI_FRAME_PROBE_RESP, buf, len);
2068 kfree(buf);
2069 return ret;
2070 }
2071
2072 static int ath6kl_ap_beacon(struct wiphy *wiphy, struct net_device *dev,
2073 struct beacon_parameters *info, bool add)
2074 {
2075 struct ath6kl *ar = ath6kl_priv(dev);
2076 struct ath6kl_vif *vif = netdev_priv(dev);
2077 struct ieee80211_mgmt *mgmt;
2078 u8 *ies;
2079 int ies_len;
2080 struct wmi_connect_cmd p;
2081 int res;
2082 int i, ret;
2083
2084 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: add=%d\n", __func__, add);
2085
2086 if (!ath6kl_cfg80211_ready(vif))
2087 return -EIO;
2088
2089 if (vif->next_mode != AP_NETWORK)
2090 return -EOPNOTSUPP;
2091
2092 if (info->beacon_ies) {
2093 res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2094 WMI_FRAME_BEACON,
2095 info->beacon_ies,
2096 info->beacon_ies_len);
2097 if (res)
2098 return res;
2099 }
2100 if (info->proberesp_ies) {
2101 res = ath6kl_set_ap_probe_resp_ies(vif, info->proberesp_ies,
2102 info->proberesp_ies_len);
2103 if (res)
2104 return res;
2105 }
2106 if (info->assocresp_ies) {
2107 res = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2108 WMI_FRAME_ASSOC_RESP,
2109 info->assocresp_ies,
2110 info->assocresp_ies_len);
2111 if (res)
2112 return res;
2113 }
2114
2115 if (!add)
2116 return 0;
2117
2118 ar->ap_mode_bkey.valid = false;
2119
2120 /* TODO:
2121 * info->interval
2122 * info->dtim_period
2123 */
2124
2125 if (info->head == NULL)
2126 return -EINVAL;
2127 mgmt = (struct ieee80211_mgmt *) info->head;
2128 ies = mgmt->u.beacon.variable;
2129 if (ies > info->head + info->head_len)
2130 return -EINVAL;
2131 ies_len = info->head + info->head_len - ies;
2132
2133 if (info->ssid == NULL)
2134 return -EINVAL;
2135 memcpy(vif->ssid, info->ssid, info->ssid_len);
2136 vif->ssid_len = info->ssid_len;
2137 if (info->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE)
2138 return -EOPNOTSUPP; /* TODO */
2139
2140 ret = ath6kl_set_auth_type(vif, info->auth_type);
2141 if (ret)
2142 return ret;
2143
2144 memset(&p, 0, sizeof(p));
2145
2146 for (i = 0; i < info->crypto.n_akm_suites; i++) {
2147 switch (info->crypto.akm_suites[i]) {
2148 case WLAN_AKM_SUITE_8021X:
2149 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2150 p.auth_mode |= WPA_AUTH;
2151 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2152 p.auth_mode |= WPA2_AUTH;
2153 break;
2154 case WLAN_AKM_SUITE_PSK:
2155 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
2156 p.auth_mode |= WPA_PSK_AUTH;
2157 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
2158 p.auth_mode |= WPA2_PSK_AUTH;
2159 break;
2160 }
2161 }
2162 if (p.auth_mode == 0)
2163 p.auth_mode = NONE_AUTH;
2164 vif->auth_mode = p.auth_mode;
2165
2166 for (i = 0; i < info->crypto.n_ciphers_pairwise; i++) {
2167 switch (info->crypto.ciphers_pairwise[i]) {
2168 case WLAN_CIPHER_SUITE_WEP40:
2169 case WLAN_CIPHER_SUITE_WEP104:
2170 p.prwise_crypto_type |= WEP_CRYPT;
2171 break;
2172 case WLAN_CIPHER_SUITE_TKIP:
2173 p.prwise_crypto_type |= TKIP_CRYPT;
2174 break;
2175 case WLAN_CIPHER_SUITE_CCMP:
2176 p.prwise_crypto_type |= AES_CRYPT;
2177 break;
2178 case WLAN_CIPHER_SUITE_SMS4:
2179 p.prwise_crypto_type |= WAPI_CRYPT;
2180 break;
2181 }
2182 }
2183 if (p.prwise_crypto_type == 0) {
2184 p.prwise_crypto_type = NONE_CRYPT;
2185 ath6kl_set_cipher(vif, 0, true);
2186 } else if (info->crypto.n_ciphers_pairwise == 1)
2187 ath6kl_set_cipher(vif, info->crypto.ciphers_pairwise[0], true);
2188
2189 switch (info->crypto.cipher_group) {
2190 case WLAN_CIPHER_SUITE_WEP40:
2191 case WLAN_CIPHER_SUITE_WEP104:
2192 p.grp_crypto_type = WEP_CRYPT;
2193 break;
2194 case WLAN_CIPHER_SUITE_TKIP:
2195 p.grp_crypto_type = TKIP_CRYPT;
2196 break;
2197 case WLAN_CIPHER_SUITE_CCMP:
2198 p.grp_crypto_type = AES_CRYPT;
2199 break;
2200 case WLAN_CIPHER_SUITE_SMS4:
2201 p.grp_crypto_type = WAPI_CRYPT;
2202 break;
2203 default:
2204 p.grp_crypto_type = NONE_CRYPT;
2205 break;
2206 }
2207 ath6kl_set_cipher(vif, info->crypto.cipher_group, false);
2208
2209 p.nw_type = AP_NETWORK;
2210 vif->nw_type = vif->next_mode;
2211
2212 p.ssid_len = vif->ssid_len;
2213 memcpy(p.ssid, vif->ssid, vif->ssid_len);
2214 p.dot11_auth_mode = vif->dot11_auth_mode;
2215 p.ch = cpu_to_le16(vif->next_chan);
2216
2217 if (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
2218 p.nw_subtype = SUBTYPE_P2PGO;
2219 } else {
2220 /*
2221 * Due to firmware limitation, it is not possible to
2222 * do P2P mgmt operations in AP mode
2223 */
2224 p.nw_subtype = SUBTYPE_NONE;
2225 }
2226
2227 res = ath6kl_wmi_ap_profile_commit(ar->wmi, vif->fw_vif_idx, &p);
2228 if (res < 0)
2229 return res;
2230
2231 return 0;
2232 }
2233
2234 static int ath6kl_add_beacon(struct wiphy *wiphy, struct net_device *dev,
2235 struct beacon_parameters *info)
2236 {
2237 return ath6kl_ap_beacon(wiphy, dev, info, true);
2238 }
2239
2240 static int ath6kl_set_beacon(struct wiphy *wiphy, struct net_device *dev,
2241 struct beacon_parameters *info)
2242 {
2243 return ath6kl_ap_beacon(wiphy, dev, info, false);
2244 }
2245
2246 static int ath6kl_del_beacon(struct wiphy *wiphy, struct net_device *dev)
2247 {
2248 struct ath6kl *ar = ath6kl_priv(dev);
2249 struct ath6kl_vif *vif = netdev_priv(dev);
2250
2251 if (vif->nw_type != AP_NETWORK)
2252 return -EOPNOTSUPP;
2253 if (!test_bit(CONNECTED, &vif->flags))
2254 return -ENOTCONN;
2255
2256 ath6kl_wmi_disconnect_cmd(ar->wmi, vif->fw_vif_idx);
2257 clear_bit(CONNECTED, &vif->flags);
2258
2259 return 0;
2260 }
2261
2262 static int ath6kl_change_station(struct wiphy *wiphy, struct net_device *dev,
2263 u8 *mac, struct station_parameters *params)
2264 {
2265 struct ath6kl *ar = ath6kl_priv(dev);
2266 struct ath6kl_vif *vif = netdev_priv(dev);
2267
2268 if (vif->nw_type != AP_NETWORK)
2269 return -EOPNOTSUPP;
2270
2271 /* Use this only for authorizing/unauthorizing a station */
2272 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
2273 return -EOPNOTSUPP;
2274
2275 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
2276 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
2277 WMI_AP_MLME_AUTHORIZE, mac, 0);
2278 return ath6kl_wmi_ap_set_mlme(ar->wmi, vif->fw_vif_idx,
2279 WMI_AP_MLME_UNAUTHORIZE, mac, 0);
2280 }
2281
2282 static int ath6kl_remain_on_channel(struct wiphy *wiphy,
2283 struct net_device *dev,
2284 struct ieee80211_channel *chan,
2285 enum nl80211_channel_type channel_type,
2286 unsigned int duration,
2287 u64 *cookie)
2288 {
2289 struct ath6kl *ar = ath6kl_priv(dev);
2290 struct ath6kl_vif *vif = netdev_priv(dev);
2291 u32 id;
2292
2293 /* TODO: if already pending or ongoing remain-on-channel,
2294 * return -EBUSY */
2295 id = ++vif->last_roc_id;
2296 if (id == 0) {
2297 /* Do not use 0 as the cookie value */
2298 id = ++vif->last_roc_id;
2299 }
2300 *cookie = id;
2301
2302 return ath6kl_wmi_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx,
2303 chan->center_freq, duration);
2304 }
2305
2306 static int ath6kl_cancel_remain_on_channel(struct wiphy *wiphy,
2307 struct net_device *dev,
2308 u64 cookie)
2309 {
2310 struct ath6kl *ar = ath6kl_priv(dev);
2311 struct ath6kl_vif *vif = netdev_priv(dev);
2312
2313 if (cookie != vif->last_roc_id)
2314 return -ENOENT;
2315 vif->last_cancel_roc_id = cookie;
2316
2317 return ath6kl_wmi_cancel_remain_on_chnl_cmd(ar->wmi, vif->fw_vif_idx);
2318 }
2319
2320 static int ath6kl_send_go_probe_resp(struct ath6kl_vif *vif,
2321 const u8 *buf, size_t len,
2322 unsigned int freq)
2323 {
2324 struct ath6kl *ar = vif->ar;
2325 const u8 *pos;
2326 u8 *p2p;
2327 int p2p_len;
2328 int ret;
2329 const struct ieee80211_mgmt *mgmt;
2330
2331 mgmt = (const struct ieee80211_mgmt *) buf;
2332
2333 /* Include P2P IE(s) from the frame generated in user space. */
2334
2335 p2p = kmalloc(len, GFP_KERNEL);
2336 if (p2p == NULL)
2337 return -ENOMEM;
2338 p2p_len = 0;
2339
2340 pos = mgmt->u.probe_resp.variable;
2341 while (pos + 1 < buf + len) {
2342 if (pos + 2 + pos[1] > buf + len)
2343 break;
2344 if (ath6kl_is_p2p_ie(pos)) {
2345 memcpy(p2p + p2p_len, pos, 2 + pos[1]);
2346 p2p_len += 2 + pos[1];
2347 }
2348 pos += 2 + pos[1];
2349 }
2350
2351 ret = ath6kl_wmi_send_probe_response_cmd(ar->wmi, vif->fw_vif_idx, freq,
2352 mgmt->da, p2p, p2p_len);
2353 kfree(p2p);
2354 return ret;
2355 }
2356
2357 static int ath6kl_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
2358 struct ieee80211_channel *chan, bool offchan,
2359 enum nl80211_channel_type channel_type,
2360 bool channel_type_valid, unsigned int wait,
2361 const u8 *buf, size_t len, bool no_cck,
2362 bool dont_wait_for_ack, u64 *cookie)
2363 {
2364 struct ath6kl *ar = ath6kl_priv(dev);
2365 struct ath6kl_vif *vif = netdev_priv(dev);
2366 u32 id;
2367 const struct ieee80211_mgmt *mgmt;
2368
2369 mgmt = (const struct ieee80211_mgmt *) buf;
2370 if (buf + len >= mgmt->u.probe_resp.variable &&
2371 vif->nw_type == AP_NETWORK && test_bit(CONNECTED, &vif->flags) &&
2372 ieee80211_is_probe_resp(mgmt->frame_control)) {
2373 /*
2374 * Send Probe Response frame in AP mode using a separate WMI
2375 * command to allow the target to fill in the generic IEs.
2376 */
2377 *cookie = 0; /* TX status not supported */
2378 return ath6kl_send_go_probe_resp(vif, buf, len,
2379 chan->center_freq);
2380 }
2381
2382 id = vif->send_action_id++;
2383 if (id == 0) {
2384 /*
2385 * 0 is a reserved value in the WMI command and shall not be
2386 * used for the command.
2387 */
2388 id = vif->send_action_id++;
2389 }
2390
2391 *cookie = id;
2392
2393 if (test_bit(ATH6KL_FW_CAPABILITY_STA_P2PDEV_DUPLEX,
2394 ar->fw_capabilities)) {
2395 /*
2396 * If capable of doing P2P mgmt operations using
2397 * station interface, send additional information like
2398 * supported rates to advertise and xmit rates for
2399 * probe requests
2400 */
2401 return ath6kl_wmi_send_mgmt_cmd(ar->wmi, vif->fw_vif_idx, id,
2402 chan->center_freq, wait,
2403 buf, len, no_cck);
2404 } else {
2405 return ath6kl_wmi_send_action_cmd(ar->wmi, vif->fw_vif_idx, id,
2406 chan->center_freq, wait,
2407 buf, len);
2408 }
2409 }
2410
2411 static void ath6kl_mgmt_frame_register(struct wiphy *wiphy,
2412 struct net_device *dev,
2413 u16 frame_type, bool reg)
2414 {
2415 struct ath6kl_vif *vif = netdev_priv(dev);
2416
2417 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: frame_type=0x%x reg=%d\n",
2418 __func__, frame_type, reg);
2419 if (frame_type == IEEE80211_STYPE_PROBE_REQ) {
2420 /*
2421 * Note: This notification callback is not allowed to sleep, so
2422 * we cannot send WMI_PROBE_REQ_REPORT_CMD here. Instead, we
2423 * hardcode target to report Probe Request frames all the time.
2424 */
2425 vif->probe_req_report = reg;
2426 }
2427 }
2428
2429 static int ath6kl_cfg80211_sscan_start(struct wiphy *wiphy,
2430 struct net_device *dev,
2431 struct cfg80211_sched_scan_request *request)
2432 {
2433 struct ath6kl *ar = ath6kl_priv(dev);
2434 struct ath6kl_vif *vif = netdev_priv(dev);
2435 u16 interval;
2436 int ret;
2437 u8 i;
2438
2439 if (ar->state != ATH6KL_STATE_ON)
2440 return -EIO;
2441
2442 if (vif->sme_state != SME_DISCONNECTED)
2443 return -EBUSY;
2444
2445 for (i = 0; i < ar->wiphy->max_sched_scan_ssids; i++) {
2446 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx,
2447 i, DISABLE_SSID_FLAG,
2448 0, NULL);
2449 }
2450
2451 /* fw uses seconds, also make sure that it's >0 */
2452 interval = max_t(u16, 1, request->interval / 1000);
2453
2454 ath6kl_wmi_scanparams_cmd(ar->wmi, vif->fw_vif_idx,
2455 interval, interval,
2456 10, 0, 0, 0, 3, 0, 0, 0);
2457
2458 if (request->n_ssids && request->ssids[0].ssid_len) {
2459 for (i = 0; i < request->n_ssids; i++) {
2460 ath6kl_wmi_probedssid_cmd(ar->wmi, vif->fw_vif_idx,
2461 i, SPECIFIC_SSID_FLAG,
2462 request->ssids[i].ssid_len,
2463 request->ssids[i].ssid);
2464 }
2465 }
2466
2467 ret = ath6kl_wmi_set_wow_mode_cmd(ar->wmi, vif->fw_vif_idx,
2468 ATH6KL_WOW_MODE_ENABLE,
2469 WOW_FILTER_SSID,
2470 WOW_HOST_REQ_DELAY);
2471 if (ret) {
2472 ath6kl_warn("Failed to enable wow with ssid filter: %d\n", ret);
2473 return ret;
2474 }
2475
2476 /* this also clears IE in fw if it's not set */
2477 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, vif->fw_vif_idx,
2478 WMI_FRAME_PROBE_REQ,
2479 request->ie, request->ie_len);
2480 if (ret) {
2481 ath6kl_warn("Failed to set probe request IE for scheduled scan: %d",
2482 ret);
2483 return ret;
2484 }
2485
2486 ret = ath6kl_wmi_set_host_sleep_mode_cmd(ar->wmi, vif->fw_vif_idx,
2487 ATH6KL_HOST_MODE_ASLEEP);
2488 if (ret) {
2489 ath6kl_warn("Failed to enable host sleep mode for sched scan: %d\n",
2490 ret);
2491 return ret;
2492 }
2493
2494 ar->state = ATH6KL_STATE_SCHED_SCAN;
2495
2496 return ret;
2497 }
2498
2499 static int ath6kl_cfg80211_sscan_stop(struct wiphy *wiphy,
2500 struct net_device *dev)
2501 {
2502 struct ath6kl_vif *vif = netdev_priv(dev);
2503 bool stopped;
2504
2505 stopped = __ath6kl_cfg80211_sscan_stop(vif);
2506
2507 if (!stopped)
2508 return -EIO;
2509
2510 return 0;
2511 }
2512
2513 static const struct ieee80211_txrx_stypes
2514 ath6kl_mgmt_stypes[NUM_NL80211_IFTYPES] = {
2515 [NL80211_IFTYPE_STATION] = {
2516 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
2517 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
2518 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
2519 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
2520 },
2521 [NL80211_IFTYPE_P2P_CLIENT] = {
2522 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
2523 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
2524 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
2525 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
2526 },
2527 [NL80211_IFTYPE_P2P_GO] = {
2528 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
2529 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
2530 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
2531 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
2532 },
2533 };
2534
2535 static struct cfg80211_ops ath6kl_cfg80211_ops = {
2536 .add_virtual_intf = ath6kl_cfg80211_add_iface,
2537 .del_virtual_intf = ath6kl_cfg80211_del_iface,
2538 .change_virtual_intf = ath6kl_cfg80211_change_iface,
2539 .scan = ath6kl_cfg80211_scan,
2540 .connect = ath6kl_cfg80211_connect,
2541 .disconnect = ath6kl_cfg80211_disconnect,
2542 .add_key = ath6kl_cfg80211_add_key,
2543 .get_key = ath6kl_cfg80211_get_key,
2544 .del_key = ath6kl_cfg80211_del_key,
2545 .set_default_key = ath6kl_cfg80211_set_default_key,
2546 .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
2547 .set_tx_power = ath6kl_cfg80211_set_txpower,
2548 .get_tx_power = ath6kl_cfg80211_get_txpower,
2549 .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
2550 .join_ibss = ath6kl_cfg80211_join_ibss,
2551 .leave_ibss = ath6kl_cfg80211_leave_ibss,
2552 .get_station = ath6kl_get_station,
2553 .set_pmksa = ath6kl_set_pmksa,
2554 .del_pmksa = ath6kl_del_pmksa,
2555 .flush_pmksa = ath6kl_flush_pmksa,
2556 CFG80211_TESTMODE_CMD(ath6kl_tm_cmd)
2557 #ifdef CONFIG_PM
2558 .suspend = __ath6kl_cfg80211_suspend,
2559 .resume = __ath6kl_cfg80211_resume,
2560 #endif
2561 .set_channel = ath6kl_set_channel,
2562 .add_beacon = ath6kl_add_beacon,
2563 .set_beacon = ath6kl_set_beacon,
2564 .del_beacon = ath6kl_del_beacon,
2565 .change_station = ath6kl_change_station,
2566 .remain_on_channel = ath6kl_remain_on_channel,
2567 .cancel_remain_on_channel = ath6kl_cancel_remain_on_channel,
2568 .mgmt_tx = ath6kl_mgmt_tx,
2569 .mgmt_frame_register = ath6kl_mgmt_frame_register,
2570 .sched_scan_start = ath6kl_cfg80211_sscan_start,
2571 .sched_scan_stop = ath6kl_cfg80211_sscan_stop,
2572 };
2573
2574 void ath6kl_cfg80211_stop(struct ath6kl_vif *vif)
2575 {
2576 ath6kl_cfg80211_sscan_disable(vif);
2577
2578 switch (vif->sme_state) {
2579 case SME_DISCONNECTED:
2580 break;
2581 case SME_CONNECTING:
2582 cfg80211_connect_result(vif->ndev, vif->bssid, NULL, 0,
2583 NULL, 0,
2584 WLAN_STATUS_UNSPECIFIED_FAILURE,
2585 GFP_KERNEL);
2586 break;
2587 case SME_CONNECTED:
2588 cfg80211_disconnected(vif->ndev, 0, NULL, 0, GFP_KERNEL);
2589 break;
2590 }
2591
2592 if (test_bit(CONNECTED, &vif->flags) ||
2593 test_bit(CONNECT_PEND, &vif->flags))
2594 ath6kl_wmi_disconnect_cmd(vif->ar->wmi, vif->fw_vif_idx);
2595
2596 vif->sme_state = SME_DISCONNECTED;
2597 clear_bit(CONNECTED, &vif->flags);
2598 clear_bit(CONNECT_PEND, &vif->flags);
2599
2600 /* disable scanning */
2601 if (ath6kl_wmi_scanparams_cmd(vif->ar->wmi, vif->fw_vif_idx, 0xFFFF,
2602 0, 0, 0, 0, 0, 0, 0, 0, 0) != 0)
2603 ath6kl_warn("failed to disable scan during stop\n");
2604
2605 ath6kl_cfg80211_scan_complete_event(vif, true);
2606 }
2607
2608 void ath6kl_cfg80211_stop_all(struct ath6kl *ar)
2609 {
2610 struct ath6kl_vif *vif;
2611
2612 vif = ath6kl_vif_first(ar);
2613 if (!vif) {
2614 /* save the current power mode before enabling power save */
2615 ar->wmi->saved_pwr_mode = ar->wmi->pwr_mode;
2616
2617 if (ath6kl_wmi_powermode_cmd(ar->wmi, 0, REC_POWER) != 0)
2618 ath6kl_warn("ath6kl_deep_sleep_enable: "
2619 "wmi_powermode_cmd failed\n");
2620 return;
2621 }
2622
2623 /*
2624 * FIXME: we should take ar->list_lock to protect changes in the
2625 * vif_list, but that's not trivial to do as ath6kl_cfg80211_stop()
2626 * sleeps.
2627 */
2628 list_for_each_entry(vif, &ar->vif_list, list)
2629 ath6kl_cfg80211_stop(vif);
2630 }
2631
2632 struct ath6kl *ath6kl_core_alloc(struct device *dev)
2633 {
2634 struct ath6kl *ar;
2635 struct wiphy *wiphy;
2636 u8 ctr;
2637
2638 /* create a new wiphy for use with cfg80211 */
2639 wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
2640
2641 if (!wiphy) {
2642 ath6kl_err("couldn't allocate wiphy device\n");
2643 return NULL;
2644 }
2645
2646 ar = wiphy_priv(wiphy);
2647 ar->p2p = !!ath6kl_p2p;
2648 ar->wiphy = wiphy;
2649 ar->dev = dev;
2650
2651 ar->vif_max = 1;
2652
2653 ar->max_norm_iface = 1;
2654
2655 spin_lock_init(&ar->lock);
2656 spin_lock_init(&ar->mcastpsq_lock);
2657 spin_lock_init(&ar->list_lock);
2658
2659 init_waitqueue_head(&ar->event_wq);
2660 sema_init(&ar->sem, 1);
2661
2662 INIT_LIST_HEAD(&ar->amsdu_rx_buffer_queue);
2663 INIT_LIST_HEAD(&ar->vif_list);
2664
2665 clear_bit(WMI_ENABLED, &ar->flag);
2666 clear_bit(SKIP_SCAN, &ar->flag);
2667 clear_bit(DESTROY_IN_PROGRESS, &ar->flag);
2668
2669 ar->listen_intvl_t = A_DEFAULT_LISTEN_INTERVAL;
2670 ar->listen_intvl_b = 0;
2671 ar->tx_pwr = 0;
2672
2673 ar->intra_bss = 1;
2674 ar->lrssi_roam_threshold = DEF_LRSSI_ROAM_THRESHOLD;
2675
2676 ar->state = ATH6KL_STATE_OFF;
2677
2678 memset((u8 *)ar->sta_list, 0,
2679 AP_MAX_NUM_STA * sizeof(struct ath6kl_sta));
2680
2681 /* Init the PS queues */
2682 for (ctr = 0; ctr < AP_MAX_NUM_STA; ctr++) {
2683 spin_lock_init(&ar->sta_list[ctr].psq_lock);
2684 skb_queue_head_init(&ar->sta_list[ctr].psq);
2685 }
2686
2687 skb_queue_head_init(&ar->mcastpsq);
2688
2689 memcpy(ar->ap_country_code, DEF_AP_COUNTRY_CODE, 3);
2690
2691 return ar;
2692 }
2693
2694 int ath6kl_register_ieee80211_hw(struct ath6kl *ar)
2695 {
2696 struct wiphy *wiphy = ar->wiphy;
2697 int ret;
2698
2699 wiphy->mgmt_stypes = ath6kl_mgmt_stypes;
2700
2701 wiphy->max_remain_on_channel_duration = 5000;
2702
2703 /* set device pointer for wiphy */
2704 set_wiphy_dev(wiphy, ar->dev);
2705
2706 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2707 BIT(NL80211_IFTYPE_ADHOC) |
2708 BIT(NL80211_IFTYPE_AP);
2709 if (ar->p2p) {
2710 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_GO) |
2711 BIT(NL80211_IFTYPE_P2P_CLIENT);
2712 }
2713
2714 /* max num of ssids that can be probed during scanning */
2715 wiphy->max_scan_ssids = MAX_PROBED_SSID_INDEX;
2716 wiphy->max_scan_ie_len = 1000; /* FIX: what is correct limit? */
2717 wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
2718 wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
2719 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2720
2721 wiphy->cipher_suites = cipher_suites;
2722 wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
2723
2724 wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
2725 WIPHY_WOWLAN_DISCONNECT |
2726 WIPHY_WOWLAN_GTK_REKEY_FAILURE |
2727 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
2728 WIPHY_WOWLAN_EAP_IDENTITY_REQ |
2729 WIPHY_WOWLAN_4WAY_HANDSHAKE;
2730 wiphy->wowlan.n_patterns = WOW_MAX_FILTERS_PER_LIST;
2731 wiphy->wowlan.pattern_min_len = 1;
2732 wiphy->wowlan.pattern_max_len = WOW_PATTERN_SIZE;
2733
2734 wiphy->max_sched_scan_ssids = 10;
2735
2736 ret = wiphy_register(wiphy);
2737 if (ret < 0) {
2738 ath6kl_err("couldn't register wiphy device\n");
2739 return ret;
2740 }
2741
2742 return 0;
2743 }
2744
2745 static int ath6kl_init_if_data(struct ath6kl_vif *vif)
2746 {
2747 vif->aggr_cntxt = aggr_init(vif->ndev);
2748 if (!vif->aggr_cntxt) {
2749 ath6kl_err("failed to initialize aggr\n");
2750 return -ENOMEM;
2751 }
2752
2753 setup_timer(&vif->disconnect_timer, disconnect_timer_handler,
2754 (unsigned long) vif->ndev);
2755 setup_timer(&vif->sched_scan_timer, ath6kl_wmi_sscan_timer,
2756 (unsigned long) vif);
2757
2758 set_bit(WMM_ENABLED, &vif->flags);
2759 spin_lock_init(&vif->if_lock);
2760
2761 return 0;
2762 }
2763
2764 void ath6kl_deinit_if_data(struct ath6kl_vif *vif)
2765 {
2766 struct ath6kl *ar = vif->ar;
2767
2768 aggr_module_destroy(vif->aggr_cntxt);
2769
2770 ar->avail_idx_map |= BIT(vif->fw_vif_idx);
2771
2772 if (vif->nw_type == ADHOC_NETWORK)
2773 ar->ibss_if_active = false;
2774
2775 unregister_netdevice(vif->ndev);
2776
2777 ar->num_vif--;
2778 }
2779
2780 struct net_device *ath6kl_interface_add(struct ath6kl *ar, char *name,
2781 enum nl80211_iftype type, u8 fw_vif_idx,
2782 u8 nw_type)
2783 {
2784 struct net_device *ndev;
2785 struct ath6kl_vif *vif;
2786
2787 ndev = alloc_netdev(sizeof(*vif), name, ether_setup);
2788 if (!ndev)
2789 return NULL;
2790
2791 vif = netdev_priv(ndev);
2792 ndev->ieee80211_ptr = &vif->wdev;
2793 vif->wdev.wiphy = ar->wiphy;
2794 vif->ar = ar;
2795 vif->ndev = ndev;
2796 SET_NETDEV_DEV(ndev, wiphy_dev(vif->wdev.wiphy));
2797 vif->wdev.netdev = ndev;
2798 vif->wdev.iftype = type;
2799 vif->fw_vif_idx = fw_vif_idx;
2800 vif->nw_type = vif->next_mode = nw_type;
2801
2802 memcpy(ndev->dev_addr, ar->mac_addr, ETH_ALEN);
2803 if (fw_vif_idx != 0)
2804 ndev->dev_addr[0] = (ndev->dev_addr[0] ^ (1 << fw_vif_idx)) |
2805 0x2;
2806
2807 init_netdev(ndev);
2808
2809 ath6kl_init_control_info(vif);
2810
2811 /* TODO: Pass interface specific pointer instead of ar */
2812 if (ath6kl_init_if_data(vif))
2813 goto err;
2814
2815 if (register_netdevice(ndev))
2816 goto err;
2817
2818 ar->avail_idx_map &= ~BIT(fw_vif_idx);
2819 vif->sme_state = SME_DISCONNECTED;
2820 set_bit(WLAN_ENABLED, &vif->flags);
2821 ar->wlan_pwr_state = WLAN_POWER_STATE_ON;
2822 set_bit(NETDEV_REGISTERED, &vif->flags);
2823
2824 if (type == NL80211_IFTYPE_ADHOC)
2825 ar->ibss_if_active = true;
2826
2827 spin_lock_bh(&ar->list_lock);
2828 list_add_tail(&vif->list, &ar->vif_list);
2829 spin_unlock_bh(&ar->list_lock);
2830
2831 return ndev;
2832
2833 err:
2834 aggr_module_destroy(vif->aggr_cntxt);
2835 free_netdev(ndev);
2836 return NULL;
2837 }
2838
2839 void ath6kl_deinit_ieee80211_hw(struct ath6kl *ar)
2840 {
2841 wiphy_unregister(ar->wiphy);
2842 wiphy_free(ar->wiphy);
2843 }