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