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