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