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