projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/padovan/bluetooth
[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
25 module_param(ath6kl_p2p, uint, 0644);
26
27 #define RATETAB_ENT(_rate, _rateid, _flags) { \
28 .bitrate = (_rate), \
29 .flags = (_flags), \
30 .hw_value = (_rateid), \
31 }
32
33 #define CHAN2G(_channel, _freq, _flags) { \
34 .band = IEEE80211_BAND_2GHZ, \
35 .hw_value = (_channel), \
36 .center_freq = (_freq), \
37 .flags = (_flags), \
38 .max_antenna_gain = 0, \
39 .max_power = 30, \
40 }
41
42 #define CHAN5G(_channel, _flags) { \
43 .band = IEEE80211_BAND_5GHZ, \
44 .hw_value = (_channel), \
45 .center_freq = 5000 + (5 * (_channel)), \
46 .flags = (_flags), \
47 .max_antenna_gain = 0, \
48 .max_power = 30, \
49 }
50
51 static struct ieee80211_rate ath6kl_rates[] = {
52 RATETAB_ENT(10, 0x1, 0),
53 RATETAB_ENT(20, 0x2, 0),
54 RATETAB_ENT(55, 0x4, 0),
55 RATETAB_ENT(110, 0x8, 0),
56 RATETAB_ENT(60, 0x10, 0),
57 RATETAB_ENT(90, 0x20, 0),
58 RATETAB_ENT(120, 0x40, 0),
59 RATETAB_ENT(180, 0x80, 0),
60 RATETAB_ENT(240, 0x100, 0),
61 RATETAB_ENT(360, 0x200, 0),
62 RATETAB_ENT(480, 0x400, 0),
63 RATETAB_ENT(540, 0x800, 0),
64 };
65
66 #define ath6kl_a_rates (ath6kl_rates + 4)
67 #define ath6kl_a_rates_size 8
68 #define ath6kl_g_rates (ath6kl_rates + 0)
69 #define ath6kl_g_rates_size 12
70
71 static struct ieee80211_channel ath6kl_2ghz_channels[] = {
72 CHAN2G(1, 2412, 0),
73 CHAN2G(2, 2417, 0),
74 CHAN2G(3, 2422, 0),
75 CHAN2G(4, 2427, 0),
76 CHAN2G(5, 2432, 0),
77 CHAN2G(6, 2437, 0),
78 CHAN2G(7, 2442, 0),
79 CHAN2G(8, 2447, 0),
80 CHAN2G(9, 2452, 0),
81 CHAN2G(10, 2457, 0),
82 CHAN2G(11, 2462, 0),
83 CHAN2G(12, 2467, 0),
84 CHAN2G(13, 2472, 0),
85 CHAN2G(14, 2484, 0),
86 };
87
88 static struct ieee80211_channel ath6kl_5ghz_a_channels[] = {
89 CHAN5G(34, 0), CHAN5G(36, 0),
90 CHAN5G(38, 0), CHAN5G(40, 0),
91 CHAN5G(42, 0), CHAN5G(44, 0),
92 CHAN5G(46, 0), CHAN5G(48, 0),
93 CHAN5G(52, 0), CHAN5G(56, 0),
94 CHAN5G(60, 0), CHAN5G(64, 0),
95 CHAN5G(100, 0), CHAN5G(104, 0),
96 CHAN5G(108, 0), CHAN5G(112, 0),
97 CHAN5G(116, 0), CHAN5G(120, 0),
98 CHAN5G(124, 0), CHAN5G(128, 0),
99 CHAN5G(132, 0), CHAN5G(136, 0),
100 CHAN5G(140, 0), CHAN5G(149, 0),
101 CHAN5G(153, 0), CHAN5G(157, 0),
102 CHAN5G(161, 0), CHAN5G(165, 0),
103 CHAN5G(184, 0), CHAN5G(188, 0),
104 CHAN5G(192, 0), CHAN5G(196, 0),
105 CHAN5G(200, 0), CHAN5G(204, 0),
106 CHAN5G(208, 0), CHAN5G(212, 0),
107 CHAN5G(216, 0),
108 };
109
110 static struct ieee80211_supported_band ath6kl_band_2ghz = {
111 .n_channels = ARRAY_SIZE(ath6kl_2ghz_channels),
112 .channels = ath6kl_2ghz_channels,
113 .n_bitrates = ath6kl_g_rates_size,
114 .bitrates = ath6kl_g_rates,
115 };
116
117 static struct ieee80211_supported_band ath6kl_band_5ghz = {
118 .n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels),
119 .channels = ath6kl_5ghz_a_channels,
120 .n_bitrates = ath6kl_a_rates_size,
121 .bitrates = ath6kl_a_rates,
122 };
123
124 static int ath6kl_set_wpa_version(struct ath6kl *ar,
125 enum nl80211_wpa_versions wpa_version)
126 {
127 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
128
129 if (!wpa_version) {
130 ar->auth_mode = NONE_AUTH;
131 } else if (wpa_version & NL80211_WPA_VERSION_2) {
132 ar->auth_mode = WPA2_AUTH;
133 } else if (wpa_version & NL80211_WPA_VERSION_1) {
134 ar->auth_mode = WPA_AUTH;
135 } else {
136 ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
137 return -ENOTSUPP;
138 }
139
140 return 0;
141 }
142
143 static int ath6kl_set_auth_type(struct ath6kl *ar,
144 enum nl80211_auth_type auth_type)
145 {
146
147 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
148
149 switch (auth_type) {
150 case NL80211_AUTHTYPE_OPEN_SYSTEM:
151 ar->dot11_auth_mode = OPEN_AUTH;
152 break;
153 case NL80211_AUTHTYPE_SHARED_KEY:
154 ar->dot11_auth_mode = SHARED_AUTH;
155 break;
156 case NL80211_AUTHTYPE_NETWORK_EAP:
157 ar->dot11_auth_mode = LEAP_AUTH;
158 break;
159
160 case NL80211_AUTHTYPE_AUTOMATIC:
161 ar->dot11_auth_mode = OPEN_AUTH | SHARED_AUTH;
162 break;
163
164 default:
165 ath6kl_err("%s: 0x%x not spported\n", __func__, auth_type);
166 return -ENOTSUPP;
167 }
168
169 return 0;
170 }
171
172 static int ath6kl_set_cipher(struct ath6kl *ar, u32 cipher, bool ucast)
173 {
174 u8 *ar_cipher = ucast ? &ar->prwise_crypto : &ar->grp_crypto;
175 u8 *ar_cipher_len = ucast ? &ar->prwise_crypto_len :
176 &ar->grp_crypto_len;
177
178 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
179 __func__, cipher, ucast);
180
181 switch (cipher) {
182 case 0:
183 /* our own hack to use value 0 as no crypto used */
184 *ar_cipher = NONE_CRYPT;
185 *ar_cipher_len = 0;
186 break;
187 case WLAN_CIPHER_SUITE_WEP40:
188 *ar_cipher = WEP_CRYPT;
189 *ar_cipher_len = 5;
190 break;
191 case WLAN_CIPHER_SUITE_WEP104:
192 *ar_cipher = WEP_CRYPT;
193 *ar_cipher_len = 13;
194 break;
195 case WLAN_CIPHER_SUITE_TKIP:
196 *ar_cipher = TKIP_CRYPT;
197 *ar_cipher_len = 0;
198 break;
199 case WLAN_CIPHER_SUITE_CCMP:
200 *ar_cipher = AES_CRYPT;
201 *ar_cipher_len = 0;
202 break;
203 default:
204 ath6kl_err("cipher 0x%x not supported\n", cipher);
205 return -ENOTSUPP;
206 }
207
208 return 0;
209 }
210
211 static void ath6kl_set_key_mgmt(struct ath6kl *ar, u32 key_mgmt)
212 {
213 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
214
215 if (key_mgmt == WLAN_AKM_SUITE_PSK) {
216 if (ar->auth_mode == WPA_AUTH)
217 ar->auth_mode = WPA_PSK_AUTH;
218 else if (ar->auth_mode == WPA2_AUTH)
219 ar->auth_mode = WPA2_PSK_AUTH;
220 } else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
221 ar->auth_mode = NONE_AUTH;
222 }
223 }
224
225 static bool ath6kl_cfg80211_ready(struct ath6kl *ar)
226 {
227 if (!test_bit(WMI_READY, &ar->flag)) {
228 ath6kl_err("wmi is not ready\n");
229 return false;
230 }
231
232 if (!test_bit(WLAN_ENABLED, &ar->flag)) {
233 ath6kl_err("wlan disabled\n");
234 return false;
235 }
236
237 return true;
238 }
239
240 static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
241 struct cfg80211_connect_params *sme)
242 {
243 struct ath6kl *ar = ath6kl_priv(dev);
244 int status;
245
246 ar->sme_state = SME_CONNECTING;
247
248 if (!ath6kl_cfg80211_ready(ar))
249 return -EIO;
250
251 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
252 ath6kl_err("destroy in progress\n");
253 return -EBUSY;
254 }
255
256 if (test_bit(SKIP_SCAN, &ar->flag) &&
257 ((sme->channel && sme->channel->center_freq == 0) ||
258 (sme->bssid && is_zero_ether_addr(sme->bssid)))) {
259 ath6kl_err("SkipScan: channel or bssid invalid\n");
260 return -EINVAL;
261 }
262
263 if (down_interruptible(&ar->sem)) {
264 ath6kl_err("busy, couldn't get access\n");
265 return -ERESTARTSYS;
266 }
267
268 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
269 ath6kl_err("busy, destroy in progress\n");
270 up(&ar->sem);
271 return -EBUSY;
272 }
273
274 if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) {
275 /*
276 * sleep until the command queue drains
277 */
278 wait_event_interruptible_timeout(ar->event_wq,
279 ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0,
280 WMI_TIMEOUT);
281 if (signal_pending(current)) {
282 ath6kl_err("cmd queue drain timeout\n");
283 up(&ar->sem);
284 return -EINTR;
285 }
286 }
287
288 if (test_bit(CONNECTED, &ar->flag) &&
289 ar->ssid_len == sme->ssid_len &&
290 !memcmp(ar->ssid, sme->ssid, ar->ssid_len)) {
291 ar->reconnect_flag = true;
292 status = ath6kl_wmi_reconnect_cmd(ar->wmi, ar->req_bssid,
293 ar->ch_hint);
294
295 up(&ar->sem);
296 if (status) {
297 ath6kl_err("wmi_reconnect_cmd failed\n");
298 return -EIO;
299 }
300 return 0;
301 } else if (ar->ssid_len == sme->ssid_len &&
302 !memcmp(ar->ssid, sme->ssid, ar->ssid_len)) {
303 ath6kl_disconnect(ar);
304 }
305
306 memset(ar->ssid, 0, sizeof(ar->ssid));
307 ar->ssid_len = sme->ssid_len;
308 memcpy(ar->ssid, sme->ssid, sme->ssid_len);
309
310 if (sme->channel)
311 ar->ch_hint = sme->channel->center_freq;
312
313 memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
314 if (sme->bssid && !is_broadcast_ether_addr(sme->bssid))
315 memcpy(ar->req_bssid, sme->bssid, sizeof(ar->req_bssid));
316
317 ath6kl_set_wpa_version(ar, sme->crypto.wpa_versions);
318
319 status = ath6kl_set_auth_type(ar, sme->auth_type);
320 if (status) {
321 up(&ar->sem);
322 return status;
323 }
324
325 if (sme->crypto.n_ciphers_pairwise)
326 ath6kl_set_cipher(ar, sme->crypto.ciphers_pairwise[0], true);
327 else
328 ath6kl_set_cipher(ar, 0, true);
329
330 ath6kl_set_cipher(ar, sme->crypto.cipher_group, false);
331
332 if (sme->crypto.n_akm_suites)
333 ath6kl_set_key_mgmt(ar, sme->crypto.akm_suites[0]);
334
335 if ((sme->key_len) &&
336 (ar->auth_mode == NONE_AUTH) && (ar->prwise_crypto == WEP_CRYPT)) {
337 struct ath6kl_key *key = NULL;
338
339 if (sme->key_idx < WMI_MIN_KEY_INDEX ||
340 sme->key_idx > WMI_MAX_KEY_INDEX) {
341 ath6kl_err("key index %d out of bounds\n",
342 sme->key_idx);
343 up(&ar->sem);
344 return -ENOENT;
345 }
346
347 key = &ar->keys[sme->key_idx];
348 key->key_len = sme->key_len;
349 memcpy(key->key, sme->key, key->key_len);
350 key->cipher = ar->prwise_crypto;
351 ar->def_txkey_index = sme->key_idx;
352
353 ath6kl_wmi_addkey_cmd(ar->wmi, sme->key_idx,
354 ar->prwise_crypto,
355 GROUP_USAGE | TX_USAGE,
356 key->key_len,
357 NULL,
358 key->key, KEY_OP_INIT_VAL, NULL,
359 NO_SYNC_WMIFLAG);
360 }
361
362 if (!ar->usr_bss_filter) {
363 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &ar->flag);
364 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, ALL_BSS_FILTER, 0) != 0) {
365 ath6kl_err("couldn't set bss filtering\n");
366 up(&ar->sem);
367 return -EIO;
368 }
369 }
370
371 ar->nw_type = ar->next_mode;
372
373 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
374 "%s: connect called with authmode %d dot11 auth %d"
375 " PW crypto %d PW crypto len %d GRP crypto %d"
376 " GRP crypto len %d channel hint %u\n",
377 __func__,
378 ar->auth_mode, ar->dot11_auth_mode, ar->prwise_crypto,
379 ar->prwise_crypto_len, ar->grp_crypto,
380 ar->grp_crypto_len, ar->ch_hint);
381
382 ar->reconnect_flag = 0;
383 status = ath6kl_wmi_connect_cmd(ar->wmi, ar->nw_type,
384 ar->dot11_auth_mode, ar->auth_mode,
385 ar->prwise_crypto,
386 ar->prwise_crypto_len,
387 ar->grp_crypto, ar->grp_crypto_len,
388 ar->ssid_len, ar->ssid,
389 ar->req_bssid, ar->ch_hint,
390 ar->connect_ctrl_flags);
391
392 up(&ar->sem);
393
394 if (status == -EINVAL) {
395 memset(ar->ssid, 0, sizeof(ar->ssid));
396 ar->ssid_len = 0;
397 ath6kl_err("invalid request\n");
398 return -ENOENT;
399 } else if (status) {
400 ath6kl_err("ath6kl_wmi_connect_cmd failed\n");
401 return -EIO;
402 }
403
404 if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) &&
405 ((ar->auth_mode == WPA_PSK_AUTH)
406 || (ar->auth_mode == WPA2_PSK_AUTH))) {
407 mod_timer(&ar->disconnect_timer,
408 jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL));
409 }
410
411 ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD;
412 set_bit(CONNECT_PEND, &ar->flag);
413
414 return 0;
415 }
416
417 static int ath6kl_add_bss_if_needed(struct ath6kl *ar, const u8 *bssid,
418 struct ieee80211_channel *chan,
419 const u8 *beacon_ie, size_t beacon_ie_len)
420 {
421 struct cfg80211_bss *bss;
422 u8 *ie;
423
424 bss = cfg80211_get_bss(ar->wdev->wiphy, chan, bssid,
425 ar->ssid, ar->ssid_len, WLAN_CAPABILITY_ESS,
426 WLAN_CAPABILITY_ESS);
427 if (bss == NULL) {
428 /*
429 * Since cfg80211 may not yet know about the BSS,
430 * generate a partial entry until the first BSS info
431 * event becomes available.
432 *
433 * Prepend SSID element since it is not included in the Beacon
434 * IEs from the target.
435 */
436 ie = kmalloc(2 + ar->ssid_len + beacon_ie_len, GFP_KERNEL);
437 if (ie == NULL)
438 return -ENOMEM;
439 ie[0] = WLAN_EID_SSID;
440 ie[1] = ar->ssid_len;
441 memcpy(ie + 2, ar->ssid, ar->ssid_len);
442 memcpy(ie + 2 + ar->ssid_len, beacon_ie, beacon_ie_len);
443 bss = cfg80211_inform_bss(ar->wdev->wiphy, chan,
444 bssid, 0, WLAN_CAPABILITY_ESS, 100,
445 ie, 2 + ar->ssid_len + beacon_ie_len,
446 0, GFP_KERNEL);
447 if (bss)
448 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "added dummy bss for "
449 "%pM prior to indicating connect/roamed "
450 "event\n", bssid);
451 kfree(ie);
452 } else
453 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "cfg80211 already has a bss "
454 "entry\n");
455
456 if (bss == NULL)
457 return -ENOMEM;
458
459 cfg80211_put_bss(bss);
460
461 return 0;
462 }
463
464 void ath6kl_cfg80211_connect_event(struct ath6kl *ar, u16 channel,
465 u8 *bssid, u16 listen_intvl,
466 u16 beacon_intvl,
467 enum network_type nw_type,
468 u8 beacon_ie_len, u8 assoc_req_len,
469 u8 assoc_resp_len, u8 *assoc_info)
470 {
471 struct ieee80211_channel *chan;
472
473 /* capinfo + listen interval */
474 u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16);
475
476 /* capinfo + status code + associd */
477 u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16);
478
479 u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset;
480 u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len +
481 assoc_resp_ie_offset;
482
483 assoc_req_len -= assoc_req_ie_offset;
484 assoc_resp_len -= assoc_resp_ie_offset;
485
486 /*
487 * Store Beacon interval here; DTIM period will be available only once
488 * a Beacon frame from the AP is seen.
489 */
490 ar->assoc_bss_beacon_int = beacon_intvl;
491 clear_bit(DTIM_PERIOD_AVAIL, &ar->flag);
492
493 if (nw_type & ADHOC_NETWORK) {
494 if (ar->wdev->iftype != NL80211_IFTYPE_ADHOC) {
495 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
496 "%s: ath6k not in ibss mode\n", __func__);
497 return;
498 }
499 }
500
501 if (nw_type & INFRA_NETWORK) {
502 if (ar->wdev->iftype != NL80211_IFTYPE_STATION &&
503 ar->wdev->iftype != NL80211_IFTYPE_P2P_CLIENT) {
504 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
505 "%s: ath6k not in station mode\n", __func__);
506 return;
507 }
508 }
509
510 chan = ieee80211_get_channel(ar->wdev->wiphy, (int) channel);
511
512
513 if (nw_type & ADHOC_NETWORK) {
514 cfg80211_ibss_joined(ar->net_dev, bssid, GFP_KERNEL);
515 return;
516 }
517
518 if (ath6kl_add_bss_if_needed(ar, bssid, chan, assoc_info,
519 beacon_ie_len) < 0) {
520 ath6kl_err("could not add cfg80211 bss entry for "
521 "connect/roamed notification\n");
522 return;
523 }
524
525 if (ar->sme_state == SME_CONNECTING) {
526 /* inform connect result to cfg80211 */
527 ar->sme_state = SME_CONNECTED;
528 cfg80211_connect_result(ar->net_dev, bssid,
529 assoc_req_ie, assoc_req_len,
530 assoc_resp_ie, assoc_resp_len,
531 WLAN_STATUS_SUCCESS, GFP_KERNEL);
532 } else if (ar->sme_state == SME_CONNECTED) {
533 /* inform roam event to cfg80211 */
534 cfg80211_roamed(ar->net_dev, chan, bssid,
535 assoc_req_ie, assoc_req_len,
536 assoc_resp_ie, assoc_resp_len, GFP_KERNEL);
537 }
538 }
539
540 static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy,
541 struct net_device *dev, u16 reason_code)
542 {
543 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(dev);
544
545 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__,
546 reason_code);
547
548 if (!ath6kl_cfg80211_ready(ar))
549 return -EIO;
550
551 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
552 ath6kl_err("busy, destroy in progress\n");
553 return -EBUSY;
554 }
555
556 if (down_interruptible(&ar->sem)) {
557 ath6kl_err("busy, couldn't get access\n");
558 return -ERESTARTSYS;
559 }
560
561 ar->reconnect_flag = 0;
562 ath6kl_disconnect(ar);
563 memset(ar->ssid, 0, sizeof(ar->ssid));
564 ar->ssid_len = 0;
565
566 if (!test_bit(SKIP_SCAN, &ar->flag))
567 memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
568
569 up(&ar->sem);
570
571 ar->sme_state = SME_DISCONNECTED;
572
573 return 0;
574 }
575
576 void ath6kl_cfg80211_disconnect_event(struct ath6kl *ar, u8 reason,
577 u8 *bssid, u8 assoc_resp_len,
578 u8 *assoc_info, u16 proto_reason)
579 {
580 if (ar->scan_req) {
581 cfg80211_scan_done(ar->scan_req, true);
582 ar->scan_req = NULL;
583 }
584
585 if (ar->nw_type & ADHOC_NETWORK) {
586 if (ar->wdev->iftype != NL80211_IFTYPE_ADHOC) {
587 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
588 "%s: ath6k not in ibss mode\n", __func__);
589 return;
590 }
591 memset(bssid, 0, ETH_ALEN);
592 cfg80211_ibss_joined(ar->net_dev, bssid, GFP_KERNEL);
593 return;
594 }
595
596 if (ar->nw_type & INFRA_NETWORK) {
597 if (ar->wdev->iftype != NL80211_IFTYPE_STATION &&
598 ar->wdev->iftype != NL80211_IFTYPE_P2P_CLIENT) {
599 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
600 "%s: ath6k not in station mode\n", __func__);
601 return;
602 }
603 }
604
605 /*
606 * Send a disconnect command to target when a disconnect event is
607 * received with reason code other than 3 (DISCONNECT_CMD - disconnect
608 * request from host) to make the firmware stop trying to connect even
609 * after giving disconnect event. There will be one more disconnect
610 * event for this disconnect command with reason code DISCONNECT_CMD
611 * which will be notified to cfg80211.
612 */
613
614 if (reason != DISCONNECT_CMD) {
615 ath6kl_wmi_disconnect_cmd(ar->wmi);
616 return;
617 }
618
619 clear_bit(CONNECT_PEND, &ar->flag);
620
621 if (ar->sme_state == SME_CONNECTING) {
622 cfg80211_connect_result(ar->net_dev,
623 bssid, NULL, 0,
624 NULL, 0,
625 WLAN_STATUS_UNSPECIFIED_FAILURE,
626 GFP_KERNEL);
627 } else if (ar->sme_state == SME_CONNECTED) {
628 cfg80211_disconnected(ar->net_dev, reason,
629 NULL, 0, GFP_KERNEL);
630 }
631
632 ar->sme_state = SME_DISCONNECTED;
633 }
634
635 static int ath6kl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
636 struct cfg80211_scan_request *request)
637 {
638 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
639 s8 n_channels = 0;
640 u16 *channels = NULL;
641 int ret = 0;
642
643 if (!ath6kl_cfg80211_ready(ar))
644 return -EIO;
645
646 if (!ar->usr_bss_filter) {
647 clear_bit(CLEAR_BSSFILTER_ON_BEACON, &ar->flag);
648 ret = ath6kl_wmi_bssfilter_cmd(
649 ar->wmi,
650 (test_bit(CONNECTED, &ar->flag) ?
651 ALL_BUT_BSS_FILTER : ALL_BSS_FILTER), 0);
652 if (ret) {
653 ath6kl_err("couldn't set bss filtering\n");
654 return ret;
655 }
656 }
657
658 if (request->n_ssids && request->ssids[0].ssid_len) {
659 u8 i;
660
661 if (request->n_ssids > (MAX_PROBED_SSID_INDEX - 1))
662 request->n_ssids = MAX_PROBED_SSID_INDEX - 1;
663
664 for (i = 0; i < request->n_ssids; i++)
665 ath6kl_wmi_probedssid_cmd(ar->wmi, i + 1,
666 SPECIFIC_SSID_FLAG,
667 request->ssids[i].ssid_len,
668 request->ssids[i].ssid);
669 }
670
671 if (request->ie) {
672 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, WMI_FRAME_PROBE_REQ,
673 request->ie, request->ie_len);
674 if (ret) {
675 ath6kl_err("failed to set Probe Request appie for "
676 "scan");
677 return ret;
678 }
679 }
680
681 /*
682 * Scan only the requested channels if the request specifies a set of
683 * channels. If the list is longer than the target supports, do not
684 * configure the list and instead, scan all available channels.
685 */
686 if (request->n_channels > 0 &&
687 request->n_channels <= WMI_MAX_CHANNELS) {
688 u8 i;
689
690 n_channels = request->n_channels;
691
692 channels = kzalloc(n_channels * sizeof(u16), GFP_KERNEL);
693 if (channels == NULL) {
694 ath6kl_warn("failed to set scan channels, "
695 "scan all channels");
696 n_channels = 0;
697 }
698
699 for (i = 0; i < n_channels; i++)
700 channels[i] = request->channels[i]->center_freq;
701 }
702
703 ret = ath6kl_wmi_startscan_cmd(ar->wmi, WMI_LONG_SCAN, 0,
704 false, 0, 0, n_channels, channels);
705 if (ret)
706 ath6kl_err("wmi_startscan_cmd failed\n");
707 else
708 ar->scan_req = request;
709
710 kfree(channels);
711
712 return ret;
713 }
714
715 void ath6kl_cfg80211_scan_complete_event(struct ath6kl *ar, int status)
716 {
717 int i;
718
719 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status %d\n", __func__, status);
720
721 if (!ar->scan_req)
722 return;
723
724 if ((status == -ECANCELED) || (status == -EBUSY)) {
725 cfg80211_scan_done(ar->scan_req, true);
726 goto out;
727 }
728
729 cfg80211_scan_done(ar->scan_req, false);
730
731 if (ar->scan_req->n_ssids && ar->scan_req->ssids[0].ssid_len) {
732 for (i = 0; i < ar->scan_req->n_ssids; i++) {
733 ath6kl_wmi_probedssid_cmd(ar->wmi, i + 1,
734 DISABLE_SSID_FLAG,
735 0, NULL);
736 }
737 }
738
739 out:
740 ar->scan_req = NULL;
741 }
742
743 static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
744 u8 key_index, bool pairwise,
745 const u8 *mac_addr,
746 struct key_params *params)
747 {
748 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
749 struct ath6kl_key *key = NULL;
750 u8 key_usage;
751 u8 key_type;
752 int status = 0;
753
754 if (!ath6kl_cfg80211_ready(ar))
755 return -EIO;
756
757 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
758 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
759 "%s: key index %d out of bounds\n", __func__,
760 key_index);
761 return -ENOENT;
762 }
763
764 key = &ar->keys[key_index];
765 memset(key, 0, sizeof(struct ath6kl_key));
766
767 if (pairwise)
768 key_usage = PAIRWISE_USAGE;
769 else
770 key_usage = GROUP_USAGE;
771
772 if (params) {
773 if (params->key_len > WLAN_MAX_KEY_LEN ||
774 params->seq_len > sizeof(key->seq))
775 return -EINVAL;
776
777 key->key_len = params->key_len;
778 memcpy(key->key, params->key, key->key_len);
779 key->seq_len = params->seq_len;
780 memcpy(key->seq, params->seq, key->seq_len);
781 key->cipher = params->cipher;
782 }
783
784 switch (key->cipher) {
785 case WLAN_CIPHER_SUITE_WEP40:
786 case WLAN_CIPHER_SUITE_WEP104:
787 key_type = WEP_CRYPT;
788 break;
789
790 case WLAN_CIPHER_SUITE_TKIP:
791 key_type = TKIP_CRYPT;
792 break;
793
794 case WLAN_CIPHER_SUITE_CCMP:
795 key_type = AES_CRYPT;
796 break;
797
798 default:
799 return -ENOTSUPP;
800 }
801
802 if (((ar->auth_mode == WPA_PSK_AUTH)
803 || (ar->auth_mode == WPA2_PSK_AUTH))
804 && (key_usage & GROUP_USAGE))
805 del_timer(&ar->disconnect_timer);
806
807 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
808 "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n",
809 __func__, key_index, key->key_len, key_type,
810 key_usage, key->seq_len);
811
812 ar->def_txkey_index = key_index;
813
814 if (ar->nw_type == AP_NETWORK && !pairwise &&
815 (key_type == TKIP_CRYPT || key_type == AES_CRYPT) && params) {
816 ar->ap_mode_bkey.valid = true;
817 ar->ap_mode_bkey.key_index = key_index;
818 ar->ap_mode_bkey.key_type = key_type;
819 ar->ap_mode_bkey.key_len = key->key_len;
820 memcpy(ar->ap_mode_bkey.key, key->key, key->key_len);
821 if (!test_bit(CONNECTED, &ar->flag)) {
822 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "Delay initial group "
823 "key configuration until AP mode has been "
824 "started\n");
825 /*
826 * The key will be set in ath6kl_connect_ap_mode() once
827 * the connected event is received from the target.
828 */
829 return 0;
830 }
831 }
832
833 if (ar->next_mode == AP_NETWORK && key_type == WEP_CRYPT &&
834 !test_bit(CONNECTED, &ar->flag)) {
835 /*
836 * Store the key locally so that it can be re-configured after
837 * the AP mode has properly started
838 * (ath6kl_install_statioc_wep_keys).
839 */
840 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "Delay WEP key configuration "
841 "until AP mode has been started\n");
842 ar->wep_key_list[key_index].key_len = key->key_len;
843 memcpy(ar->wep_key_list[key_index].key, key->key, key->key_len);
844 return 0;
845 }
846
847 status = ath6kl_wmi_addkey_cmd(ar->wmi, ar->def_txkey_index,
848 key_type, key_usage, key->key_len,
849 key->seq, key->key, KEY_OP_INIT_VAL,
850 (u8 *) mac_addr, SYNC_BOTH_WMIFLAG);
851
852 if (status)
853 return -EIO;
854
855 return 0;
856 }
857
858 static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
859 u8 key_index, bool pairwise,
860 const u8 *mac_addr)
861 {
862 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
863
864 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
865
866 if (!ath6kl_cfg80211_ready(ar))
867 return -EIO;
868
869 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
870 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
871 "%s: key index %d out of bounds\n", __func__,
872 key_index);
873 return -ENOENT;
874 }
875
876 if (!ar->keys[key_index].key_len) {
877 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
878 "%s: index %d is empty\n", __func__, key_index);
879 return 0;
880 }
881
882 ar->keys[key_index].key_len = 0;
883
884 return ath6kl_wmi_deletekey_cmd(ar->wmi, key_index);
885 }
886
887 static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
888 u8 key_index, bool pairwise,
889 const u8 *mac_addr, void *cookie,
890 void (*callback) (void *cookie,
891 struct key_params *))
892 {
893 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
894 struct ath6kl_key *key = NULL;
895 struct key_params params;
896
897 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
898
899 if (!ath6kl_cfg80211_ready(ar))
900 return -EIO;
901
902 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
903 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
904 "%s: key index %d out of bounds\n", __func__,
905 key_index);
906 return -ENOENT;
907 }
908
909 key = &ar->keys[key_index];
910 memset(&params, 0, sizeof(params));
911 params.cipher = key->cipher;
912 params.key_len = key->key_len;
913 params.seq_len = key->seq_len;
914 params.seq = key->seq;
915 params.key = key->key;
916
917 callback(cookie, &params);
918
919 return key->key_len ? 0 : -ENOENT;
920 }
921
922 static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy,
923 struct net_device *ndev,
924 u8 key_index, bool unicast,
925 bool multicast)
926 {
927 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
928 struct ath6kl_key *key = NULL;
929 int status = 0;
930 u8 key_usage;
931 enum crypto_type key_type = NONE_CRYPT;
932
933 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
934
935 if (!ath6kl_cfg80211_ready(ar))
936 return -EIO;
937
938 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
939 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
940 "%s: key index %d out of bounds\n",
941 __func__, key_index);
942 return -ENOENT;
943 }
944
945 if (!ar->keys[key_index].key_len) {
946 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n",
947 __func__, key_index);
948 return -EINVAL;
949 }
950
951 ar->def_txkey_index = key_index;
952 key = &ar->keys[ar->def_txkey_index];
953 key_usage = GROUP_USAGE;
954 if (ar->prwise_crypto == WEP_CRYPT)
955 key_usage |= TX_USAGE;
956 if (unicast)
957 key_type = ar->prwise_crypto;
958 if (multicast)
959 key_type = ar->grp_crypto;
960
961 if (ar->next_mode == AP_NETWORK && !test_bit(CONNECTED, &ar->flag))
962 return 0; /* Delay until AP mode has been started */
963
964 status = ath6kl_wmi_addkey_cmd(ar->wmi, ar->def_txkey_index,
965 key_type, key_usage,
966 key->key_len, key->seq, key->key,
967 KEY_OP_INIT_VAL, NULL,
968 SYNC_BOTH_WMIFLAG);
969 if (status)
970 return -EIO;
971
972 return 0;
973 }
974
975 void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl *ar, u8 keyid,
976 bool ismcast)
977 {
978 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
979 "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast);
980
981 cfg80211_michael_mic_failure(ar->net_dev, ar->bssid,
982 (ismcast ? NL80211_KEYTYPE_GROUP :
983 NL80211_KEYTYPE_PAIRWISE), keyid, NULL,
984 GFP_KERNEL);
985 }
986
987 static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
988 {
989 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
990 int ret;
991
992 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__,
993 changed);
994
995 if (!ath6kl_cfg80211_ready(ar))
996 return -EIO;
997
998 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
999 ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold);
1000 if (ret != 0) {
1001 ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n");
1002 return -EIO;
1003 }
1004 }
1005
1006 return 0;
1007 }
1008
1009 /*
1010 * The type nl80211_tx_power_setting replaces the following
1011 * data type from 2.6.36 onwards
1012 */
1013 static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy,
1014 enum nl80211_tx_power_setting type,
1015 int dbm)
1016 {
1017 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1018 u8 ath6kl_dbm;
1019
1020 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__,
1021 type, dbm);
1022
1023 if (!ath6kl_cfg80211_ready(ar))
1024 return -EIO;
1025
1026 switch (type) {
1027 case NL80211_TX_POWER_AUTOMATIC:
1028 return 0;
1029 case NL80211_TX_POWER_LIMITED:
1030 ar->tx_pwr = ath6kl_dbm = dbm;
1031 break;
1032 default:
1033 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n",
1034 __func__, type);
1035 return -EOPNOTSUPP;
1036 }
1037
1038 ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, ath6kl_dbm);
1039
1040 return 0;
1041 }
1042
1043 static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm)
1044 {
1045 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1046
1047 if (!ath6kl_cfg80211_ready(ar))
1048 return -EIO;
1049
1050 if (test_bit(CONNECTED, &ar->flag)) {
1051 ar->tx_pwr = 0;
1052
1053 if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi) != 0) {
1054 ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n");
1055 return -EIO;
1056 }
1057
1058 wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 0,
1059 5 * HZ);
1060
1061 if (signal_pending(current)) {
1062 ath6kl_err("target did not respond\n");
1063 return -EINTR;
1064 }
1065 }
1066
1067 *dbm = ar->tx_pwr;
1068 return 0;
1069 }
1070
1071 static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
1072 struct net_device *dev,
1073 bool pmgmt, int timeout)
1074 {
1075 struct ath6kl *ar = ath6kl_priv(dev);
1076 struct wmi_power_mode_cmd mode;
1077
1078 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n",
1079 __func__, pmgmt, timeout);
1080
1081 if (!ath6kl_cfg80211_ready(ar))
1082 return -EIO;
1083
1084 if (pmgmt) {
1085 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__);
1086 mode.pwr_mode = REC_POWER;
1087 } else {
1088 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__);
1089 mode.pwr_mode = MAX_PERF_POWER;
1090 }
1091
1092 if (ath6kl_wmi_powermode_cmd(ar->wmi, mode.pwr_mode) != 0) {
1093 ath6kl_err("wmi_powermode_cmd failed\n");
1094 return -EIO;
1095 }
1096
1097 return 0;
1098 }
1099
1100 static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy,
1101 struct net_device *ndev,
1102 enum nl80211_iftype type, u32 *flags,
1103 struct vif_params *params)
1104 {
1105 struct ath6kl *ar = ath6kl_priv(ndev);
1106 struct wireless_dev *wdev = ar->wdev;
1107
1108 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type);
1109
1110 if (!ath6kl_cfg80211_ready(ar))
1111 return -EIO;
1112
1113 switch (type) {
1114 case NL80211_IFTYPE_STATION:
1115 ar->next_mode = INFRA_NETWORK;
1116 break;
1117 case NL80211_IFTYPE_ADHOC:
1118 ar->next_mode = ADHOC_NETWORK;
1119 break;
1120 case NL80211_IFTYPE_AP:
1121 ar->next_mode = AP_NETWORK;
1122 break;
1123 case NL80211_IFTYPE_P2P_CLIENT:
1124 ar->next_mode = INFRA_NETWORK;
1125 break;
1126 case NL80211_IFTYPE_P2P_GO:
1127 ar->next_mode = AP_NETWORK;
1128 break;
1129 default:
1130 ath6kl_err("invalid interface type %u\n", type);
1131 return -EOPNOTSUPP;
1132 }
1133
1134 wdev->iftype = type;
1135
1136 return 0;
1137 }
1138
1139 static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy,
1140 struct net_device *dev,
1141 struct cfg80211_ibss_params *ibss_param)
1142 {
1143 struct ath6kl *ar = ath6kl_priv(dev);
1144 int status;
1145
1146 if (!ath6kl_cfg80211_ready(ar))
1147 return -EIO;
1148
1149 ar->ssid_len = ibss_param->ssid_len;
1150 memcpy(ar->ssid, ibss_param->ssid, ar->ssid_len);
1151
1152 if (ibss_param->channel)
1153 ar->ch_hint = ibss_param->channel->center_freq;
1154
1155 if (ibss_param->channel_fixed) {
1156 /*
1157 * TODO: channel_fixed: The channel should be fixed, do not
1158 * search for IBSSs to join on other channels. Target
1159 * firmware does not support this feature, needs to be
1160 * updated.
1161 */
1162 return -EOPNOTSUPP;
1163 }
1164
1165 memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
1166 if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid))
1167 memcpy(ar->req_bssid, ibss_param->bssid, sizeof(ar->req_bssid));
1168
1169 ath6kl_set_wpa_version(ar, 0);
1170
1171 status = ath6kl_set_auth_type(ar, NL80211_AUTHTYPE_OPEN_SYSTEM);
1172 if (status)
1173 return status;
1174
1175 if (ibss_param->privacy) {
1176 ath6kl_set_cipher(ar, WLAN_CIPHER_SUITE_WEP40, true);
1177 ath6kl_set_cipher(ar, WLAN_CIPHER_SUITE_WEP40, false);
1178 } else {
1179 ath6kl_set_cipher(ar, 0, true);
1180 ath6kl_set_cipher(ar, 0, false);
1181 }
1182
1183 ar->nw_type = ar->next_mode;
1184
1185 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1186 "%s: connect called with authmode %d dot11 auth %d"
1187 " PW crypto %d PW crypto len %d GRP crypto %d"
1188 " GRP crypto len %d channel hint %u\n",
1189 __func__,
1190 ar->auth_mode, ar->dot11_auth_mode, ar->prwise_crypto,
1191 ar->prwise_crypto_len, ar->grp_crypto,
1192 ar->grp_crypto_len, ar->ch_hint);
1193
1194 status = ath6kl_wmi_connect_cmd(ar->wmi, ar->nw_type,
1195 ar->dot11_auth_mode, ar->auth_mode,
1196 ar->prwise_crypto,
1197 ar->prwise_crypto_len,
1198 ar->grp_crypto, ar->grp_crypto_len,
1199 ar->ssid_len, ar->ssid,
1200 ar->req_bssid, ar->ch_hint,
1201 ar->connect_ctrl_flags);
1202 set_bit(CONNECT_PEND, &ar->flag);
1203
1204 return 0;
1205 }
1206
1207 static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy,
1208 struct net_device *dev)
1209 {
1210 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(dev);
1211
1212 if (!ath6kl_cfg80211_ready(ar))
1213 return -EIO;
1214
1215 ath6kl_disconnect(ar);
1216 memset(ar->ssid, 0, sizeof(ar->ssid));
1217 ar->ssid_len = 0;
1218
1219 return 0;
1220 }
1221
1222 static const u32 cipher_suites[] = {
1223 WLAN_CIPHER_SUITE_WEP40,
1224 WLAN_CIPHER_SUITE_WEP104,
1225 WLAN_CIPHER_SUITE_TKIP,
1226 WLAN_CIPHER_SUITE_CCMP,
1227 };
1228
1229 static bool is_rate_legacy(s32 rate)
1230 {
1231 static const s32 legacy[] = { 1000, 2000, 5500, 11000,
1232 6000, 9000, 12000, 18000, 24000,
1233 36000, 48000, 54000
1234 };
1235 u8 i;
1236
1237 for (i = 0; i < ARRAY_SIZE(legacy); i++)
1238 if (rate == legacy[i])
1239 return true;
1240
1241 return false;
1242 }
1243
1244 static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
1245 {
1246 static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
1247 52000, 58500, 65000, 72200
1248 };
1249 u8 i;
1250
1251 for (i = 0; i < ARRAY_SIZE(ht20); i++) {
1252 if (rate == ht20[i]) {
1253 if (i == ARRAY_SIZE(ht20) - 1)
1254 /* last rate uses sgi */
1255 *sgi = true;
1256 else
1257 *sgi = false;
1258
1259 *mcs = i;
1260 return true;
1261 }
1262 }
1263 return false;
1264 }
1265
1266 static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
1267 {
1268 static const s32 ht40[] = { 13500, 27000, 40500, 54000,
1269 81000, 108000, 121500, 135000,
1270 150000
1271 };
1272 u8 i;
1273
1274 for (i = 0; i < ARRAY_SIZE(ht40); i++) {
1275 if (rate == ht40[i]) {
1276 if (i == ARRAY_SIZE(ht40) - 1)
1277 /* last rate uses sgi */
1278 *sgi = true;
1279 else
1280 *sgi = false;
1281
1282 *mcs = i;
1283 return true;
1284 }
1285 }
1286
1287 return false;
1288 }
1289
1290 static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev,
1291 u8 *mac, struct station_info *sinfo)
1292 {
1293 struct ath6kl *ar = ath6kl_priv(dev);
1294 long left;
1295 bool sgi;
1296 s32 rate;
1297 int ret;
1298 u8 mcs;
1299
1300 if (memcmp(mac, ar->bssid, ETH_ALEN) != 0)
1301 return -ENOENT;
1302
1303 if (down_interruptible(&ar->sem))
1304 return -EBUSY;
1305
1306 set_bit(STATS_UPDATE_PEND, &ar->flag);
1307
1308 ret = ath6kl_wmi_get_stats_cmd(ar->wmi);
1309
1310 if (ret != 0) {
1311 up(&ar->sem);
1312 return -EIO;
1313 }
1314
1315 left = wait_event_interruptible_timeout(ar->event_wq,
1316 !test_bit(STATS_UPDATE_PEND,
1317 &ar->flag),
1318 WMI_TIMEOUT);
1319
1320 up(&ar->sem);
1321
1322 if (left == 0)
1323 return -ETIMEDOUT;
1324 else if (left < 0)
1325 return left;
1326
1327 if (ar->target_stats.rx_byte) {
1328 sinfo->rx_bytes = ar->target_stats.rx_byte;
1329 sinfo->filled |= STATION_INFO_RX_BYTES;
1330 sinfo->rx_packets = ar->target_stats.rx_pkt;
1331 sinfo->filled |= STATION_INFO_RX_PACKETS;
1332 }
1333
1334 if (ar->target_stats.tx_byte) {
1335 sinfo->tx_bytes = ar->target_stats.tx_byte;
1336 sinfo->filled |= STATION_INFO_TX_BYTES;
1337 sinfo->tx_packets = ar->target_stats.tx_pkt;
1338 sinfo->filled |= STATION_INFO_TX_PACKETS;
1339 }
1340
1341 sinfo->signal = ar->target_stats.cs_rssi;
1342 sinfo->filled |= STATION_INFO_SIGNAL;
1343
1344 rate = ar->target_stats.tx_ucast_rate;
1345
1346 if (is_rate_legacy(rate)) {
1347 sinfo->txrate.legacy = rate / 100;
1348 } else if (is_rate_ht20(rate, &mcs, &sgi)) {
1349 if (sgi) {
1350 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1351 sinfo->txrate.mcs = mcs - 1;
1352 } else {
1353 sinfo->txrate.mcs = mcs;
1354 }
1355
1356 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1357 } else if (is_rate_ht40(rate, &mcs, &sgi)) {
1358 if (sgi) {
1359 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1360 sinfo->txrate.mcs = mcs - 1;
1361 } else {
1362 sinfo->txrate.mcs = mcs;
1363 }
1364
1365 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
1366 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1367 } else {
1368 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1369 "invalid rate from stats: %d\n", rate);
1370 ath6kl_debug_war(ar, ATH6KL_WAR_INVALID_RATE);
1371 return 0;
1372 }
1373
1374 sinfo->filled |= STATION_INFO_TX_BITRATE;
1375
1376 if (test_bit(CONNECTED, &ar->flag) &&
1377 test_bit(DTIM_PERIOD_AVAIL, &ar->flag) &&
1378 ar->nw_type == INFRA_NETWORK) {
1379 sinfo->filled |= STATION_INFO_BSS_PARAM;
1380 sinfo->bss_param.flags = 0;
1381 sinfo->bss_param.dtim_period = ar->assoc_bss_dtim_period;
1382 sinfo->bss_param.beacon_interval = ar->assoc_bss_beacon_int;
1383 }
1384
1385 return 0;
1386 }
1387
1388 static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1389 struct cfg80211_pmksa *pmksa)
1390 {
1391 struct ath6kl *ar = ath6kl_priv(netdev);
1392 return ath6kl_wmi_setpmkid_cmd(ar->wmi, pmksa->bssid,
1393 pmksa->pmkid, true);
1394 }
1395
1396 static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1397 struct cfg80211_pmksa *pmksa)
1398 {
1399 struct ath6kl *ar = ath6kl_priv(netdev);
1400 return ath6kl_wmi_setpmkid_cmd(ar->wmi, pmksa->bssid,
1401 pmksa->pmkid, false);
1402 }
1403
1404 static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1405 {
1406 struct ath6kl *ar = ath6kl_priv(netdev);
1407 if (test_bit(CONNECTED, &ar->flag))
1408 return ath6kl_wmi_setpmkid_cmd(ar->wmi, ar->bssid, NULL, false);
1409 return 0;
1410 }
1411
1412 #ifdef CONFIG_PM
1413 static int ar6k_cfg80211_suspend(struct wiphy *wiphy,
1414 struct cfg80211_wowlan *wow)
1415 {
1416 struct ath6kl *ar = wiphy_priv(wiphy);
1417
1418 return ath6kl_hif_suspend(ar);
1419 }
1420 #endif
1421
1422 static int ath6kl_set_channel(struct wiphy *wiphy, struct net_device *dev,
1423 struct ieee80211_channel *chan,
1424 enum nl80211_channel_type channel_type)
1425 {
1426 struct ath6kl *ar = ath6kl_priv(dev);
1427
1428 if (!ath6kl_cfg80211_ready(ar))
1429 return -EIO;
1430
1431 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: center_freq=%u hw_value=%u\n",
1432 __func__, chan->center_freq, chan->hw_value);
1433 ar->next_chan = chan->center_freq;
1434
1435 return 0;
1436 }
1437
1438 static bool ath6kl_is_p2p_ie(const u8 *pos)
1439 {
1440 return pos[0] == WLAN_EID_VENDOR_SPECIFIC && pos[1] >= 4 &&
1441 pos[2] == 0x50 && pos[3] == 0x6f &&
1442 pos[4] == 0x9a && pos[5] == 0x09;
1443 }
1444
1445 static int ath6kl_set_ap_probe_resp_ies(struct ath6kl *ar, const u8 *ies,
1446 size_t ies_len)
1447 {
1448 const u8 *pos;
1449 u8 *buf = NULL;
1450 size_t len = 0;
1451 int ret;
1452
1453 /*
1454 * Filter out P2P IE(s) since they will be included depending on
1455 * the Probe Request frame in ath6kl_send_go_probe_resp().
1456 */
1457
1458 if (ies && ies_len) {
1459 buf = kmalloc(ies_len, GFP_KERNEL);
1460 if (buf == NULL)
1461 return -ENOMEM;
1462 pos = ies;
1463 while (pos + 1 < ies + ies_len) {
1464 if (pos + 2 + pos[1] > ies + ies_len)
1465 break;
1466 if (!ath6kl_is_p2p_ie(pos)) {
1467 memcpy(buf + len, pos, 2 + pos[1]);
1468 len += 2 + pos[1];
1469 }
1470 pos += 2 + pos[1];
1471 }
1472 }
1473
1474 ret = ath6kl_wmi_set_appie_cmd(ar->wmi, WMI_FRAME_PROBE_RESP,
1475 buf, len);
1476 kfree(buf);
1477 return ret;
1478 }
1479
1480 static int ath6kl_ap_beacon(struct wiphy *wiphy, struct net_device *dev,
1481 struct beacon_parameters *info, bool add)
1482 {
1483 struct ath6kl *ar = ath6kl_priv(dev);
1484 struct ieee80211_mgmt *mgmt;
1485 u8 *ies;
1486 int ies_len;
1487 struct wmi_connect_cmd p;
1488 int res;
1489 int i;
1490
1491 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: add=%d\n", __func__, add);
1492
1493 if (!ath6kl_cfg80211_ready(ar))
1494 return -EIO;
1495
1496 if (ar->next_mode != AP_NETWORK)
1497 return -EOPNOTSUPP;
1498
1499 if (info->beacon_ies) {
1500 res = ath6kl_wmi_set_appie_cmd(ar->wmi, WMI_FRAME_BEACON,
1501 info->beacon_ies,
1502 info->beacon_ies_len);
1503 if (res)
1504 return res;
1505 }
1506 if (info->proberesp_ies) {
1507 res = ath6kl_set_ap_probe_resp_ies(ar, info->proberesp_ies,
1508 info->proberesp_ies_len);
1509 if (res)
1510 return res;
1511 }
1512 if (info->assocresp_ies) {
1513 res = ath6kl_wmi_set_appie_cmd(ar->wmi, WMI_FRAME_ASSOC_RESP,
1514 info->assocresp_ies,
1515 info->assocresp_ies_len);
1516 if (res)
1517 return res;
1518 }
1519
1520 if (!add)
1521 return 0;
1522
1523 ar->ap_mode_bkey.valid = false;
1524
1525 /* TODO:
1526 * info->interval
1527 * info->dtim_period
1528 */
1529
1530 if (info->head == NULL)
1531 return -EINVAL;
1532 mgmt = (struct ieee80211_mgmt *) info->head;
1533 ies = mgmt->u.beacon.variable;
1534 if (ies > info->head + info->head_len)
1535 return -EINVAL;
1536 ies_len = info->head + info->head_len - ies;
1537
1538 if (info->ssid == NULL)
1539 return -EINVAL;
1540 memcpy(ar->ssid, info->ssid, info->ssid_len);
1541 ar->ssid_len = info->ssid_len;
1542 if (info->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE)
1543 return -EOPNOTSUPP; /* TODO */
1544
1545 ar->dot11_auth_mode = OPEN_AUTH;
1546
1547 memset(&p, 0, sizeof(p));
1548
1549 for (i = 0; i < info->crypto.n_akm_suites; i++) {
1550 switch (info->crypto.akm_suites[i]) {
1551 case WLAN_AKM_SUITE_8021X:
1552 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1553 p.auth_mode |= WPA_AUTH;
1554 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1555 p.auth_mode |= WPA2_AUTH;
1556 break;
1557 case WLAN_AKM_SUITE_PSK:
1558 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1559 p.auth_mode |= WPA_PSK_AUTH;
1560 if (info->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1561 p.auth_mode |= WPA2_PSK_AUTH;
1562 break;
1563 }
1564 }
1565 if (p.auth_mode == 0)
1566 p.auth_mode = NONE_AUTH;
1567 ar->auth_mode = p.auth_mode;
1568
1569 for (i = 0; i < info->crypto.n_ciphers_pairwise; i++) {
1570 switch (info->crypto.ciphers_pairwise[i]) {
1571 case WLAN_CIPHER_SUITE_WEP40:
1572 case WLAN_CIPHER_SUITE_WEP104:
1573 p.prwise_crypto_type |= WEP_CRYPT;
1574 break;
1575 case WLAN_CIPHER_SUITE_TKIP:
1576 p.prwise_crypto_type |= TKIP_CRYPT;
1577 break;
1578 case WLAN_CIPHER_SUITE_CCMP:
1579 p.prwise_crypto_type |= AES_CRYPT;
1580 break;
1581 }
1582 }
1583 if (p.prwise_crypto_type == 0) {
1584 p.prwise_crypto_type = NONE_CRYPT;
1585 ath6kl_set_cipher(ar, 0, true);
1586 } else if (info->crypto.n_ciphers_pairwise == 1)
1587 ath6kl_set_cipher(ar, info->crypto.ciphers_pairwise[0], true);
1588
1589 switch (info->crypto.cipher_group) {
1590 case WLAN_CIPHER_SUITE_WEP40:
1591 case WLAN_CIPHER_SUITE_WEP104:
1592 p.grp_crypto_type = WEP_CRYPT;
1593 break;
1594 case WLAN_CIPHER_SUITE_TKIP:
1595 p.grp_crypto_type = TKIP_CRYPT;
1596 break;
1597 case WLAN_CIPHER_SUITE_CCMP:
1598 p.grp_crypto_type = AES_CRYPT;
1599 break;
1600 default:
1601 p.grp_crypto_type = NONE_CRYPT;
1602 break;
1603 }
1604 ath6kl_set_cipher(ar, info->crypto.cipher_group, false);
1605
1606 p.nw_type = AP_NETWORK;
1607 ar->nw_type = ar->next_mode;
1608
1609 p.ssid_len = ar->ssid_len;
1610 memcpy(p.ssid, ar->ssid, ar->ssid_len);
1611 p.dot11_auth_mode = ar->dot11_auth_mode;
1612 p.ch = cpu_to_le16(ar->next_chan);
1613
1614 res = ath6kl_wmi_ap_profile_commit(ar->wmi, &p);
1615 if (res < 0)
1616 return res;
1617
1618 return 0;
1619 }
1620
1621 static int ath6kl_add_beacon(struct wiphy *wiphy, struct net_device *dev,
1622 struct beacon_parameters *info)
1623 {
1624 return ath6kl_ap_beacon(wiphy, dev, info, true);
1625 }
1626
1627 static int ath6kl_set_beacon(struct wiphy *wiphy, struct net_device *dev,
1628 struct beacon_parameters *info)
1629 {
1630 return ath6kl_ap_beacon(wiphy, dev, info, false);
1631 }
1632
1633 static int ath6kl_del_beacon(struct wiphy *wiphy, struct net_device *dev)
1634 {
1635 struct ath6kl *ar = ath6kl_priv(dev);
1636
1637 if (ar->nw_type != AP_NETWORK)
1638 return -EOPNOTSUPP;
1639 if (!test_bit(CONNECTED, &ar->flag))
1640 return -ENOTCONN;
1641
1642 ath6kl_wmi_disconnect_cmd(ar->wmi);
1643 clear_bit(CONNECTED, &ar->flag);
1644
1645 return 0;
1646 }
1647
1648 static int ath6kl_change_station(struct wiphy *wiphy, struct net_device *dev,
1649 u8 *mac, struct station_parameters *params)
1650 {
1651 struct ath6kl *ar = ath6kl_priv(dev);
1652
1653 if (ar->nw_type != AP_NETWORK)
1654 return -EOPNOTSUPP;
1655
1656 /* Use this only for authorizing/unauthorizing a station */
1657 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
1658 return -EOPNOTSUPP;
1659
1660 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
1661 return ath6kl_wmi_ap_set_mlme(ar->wmi, WMI_AP_MLME_AUTHORIZE,
1662 mac, 0);
1663 return ath6kl_wmi_ap_set_mlme(ar->wmi, WMI_AP_MLME_UNAUTHORIZE, mac,
1664 0);
1665 }
1666
1667 static int ath6kl_remain_on_channel(struct wiphy *wiphy,
1668 struct net_device *dev,
1669 struct ieee80211_channel *chan,
1670 enum nl80211_channel_type channel_type,
1671 unsigned int duration,
1672 u64 *cookie)
1673 {
1674 struct ath6kl *ar = ath6kl_priv(dev);
1675
1676 /* TODO: if already pending or ongoing remain-on-channel,
1677 * return -EBUSY */
1678 *cookie = 1; /* only a single pending request is supported */
1679
1680 return ath6kl_wmi_remain_on_chnl_cmd(ar->wmi, chan->center_freq,
1681 duration);
1682 }
1683
1684 static int ath6kl_cancel_remain_on_channel(struct wiphy *wiphy,
1685 struct net_device *dev,
1686 u64 cookie)
1687 {
1688 struct ath6kl *ar = ath6kl_priv(dev);
1689
1690 if (cookie != 1)
1691 return -ENOENT;
1692
1693 return ath6kl_wmi_cancel_remain_on_chnl_cmd(ar->wmi);
1694 }
1695
1696 static int ath6kl_send_go_probe_resp(struct ath6kl *ar, const u8 *buf,
1697 size_t len, unsigned int freq)
1698 {
1699 const u8 *pos;
1700 u8 *p2p;
1701 int p2p_len;
1702 int ret;
1703 const struct ieee80211_mgmt *mgmt;
1704
1705 mgmt = (const struct ieee80211_mgmt *) buf;
1706
1707 /* Include P2P IE(s) from the frame generated in user space. */
1708
1709 p2p = kmalloc(len, GFP_KERNEL);
1710 if (p2p == NULL)
1711 return -ENOMEM;
1712 p2p_len = 0;
1713
1714 pos = mgmt->u.probe_resp.variable;
1715 while (pos + 1 < buf + len) {
1716 if (pos + 2 + pos[1] > buf + len)
1717 break;
1718 if (ath6kl_is_p2p_ie(pos)) {
1719 memcpy(p2p + p2p_len, pos, 2 + pos[1]);
1720 p2p_len += 2 + pos[1];
1721 }
1722 pos += 2 + pos[1];
1723 }
1724
1725 ret = ath6kl_wmi_send_probe_response_cmd(ar->wmi, freq, mgmt->da,
1726 p2p, p2p_len);
1727 kfree(p2p);
1728 return ret;
1729 }
1730
1731 static int ath6kl_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
1732 struct ieee80211_channel *chan, bool offchan,
1733 enum nl80211_channel_type channel_type,
1734 bool channel_type_valid, unsigned int wait,
1735 const u8 *buf, size_t len, bool no_cck,
1736 bool dont_wait_for_ack, u64 *cookie)
1737 {
1738 struct ath6kl *ar = ath6kl_priv(dev);
1739 u32 id;
1740 const struct ieee80211_mgmt *mgmt;
1741
1742 mgmt = (const struct ieee80211_mgmt *) buf;
1743 if (buf + len >= mgmt->u.probe_resp.variable &&
1744 ar->nw_type == AP_NETWORK && test_bit(CONNECTED, &ar->flag) &&
1745 ieee80211_is_probe_resp(mgmt->frame_control)) {
1746 /*
1747 * Send Probe Response frame in AP mode using a separate WMI
1748 * command to allow the target to fill in the generic IEs.
1749 */
1750 *cookie = 0; /* TX status not supported */
1751 return ath6kl_send_go_probe_resp(ar, buf, len,
1752 chan->center_freq);
1753 }
1754
1755 id = ar->send_action_id++;
1756 if (id == 0) {
1757 /*
1758 * 0 is a reserved value in the WMI command and shall not be
1759 * used for the command.
1760 */
1761 id = ar->send_action_id++;
1762 }
1763
1764 *cookie = id;
1765 return ath6kl_wmi_send_action_cmd(ar->wmi, id, chan->center_freq, wait,
1766 buf, len);
1767 }
1768
1769 static void ath6kl_mgmt_frame_register(struct wiphy *wiphy,
1770 struct net_device *dev,
1771 u16 frame_type, bool reg)
1772 {
1773 struct ath6kl *ar = ath6kl_priv(dev);
1774
1775 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: frame_type=0x%x reg=%d\n",
1776 __func__, frame_type, reg);
1777 if (frame_type == IEEE80211_STYPE_PROBE_REQ) {
1778 /*
1779 * Note: This notification callback is not allowed to sleep, so
1780 * we cannot send WMI_PROBE_REQ_REPORT_CMD here. Instead, we
1781 * hardcode target to report Probe Request frames all the time.
1782 */
1783 ar->probe_req_report = reg;
1784 }
1785 }
1786
1787 static const struct ieee80211_txrx_stypes
1788 ath6kl_mgmt_stypes[NUM_NL80211_IFTYPES] = {
1789 [NL80211_IFTYPE_STATION] = {
1790 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1791 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1792 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1793 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
1794 },
1795 [NL80211_IFTYPE_P2P_CLIENT] = {
1796 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1797 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1798 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1799 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
1800 },
1801 [NL80211_IFTYPE_P2P_GO] = {
1802 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1803 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1804 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1805 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
1806 },
1807 };
1808
1809 static struct cfg80211_ops ath6kl_cfg80211_ops = {
1810 .change_virtual_intf = ath6kl_cfg80211_change_iface,
1811 .scan = ath6kl_cfg80211_scan,
1812 .connect = ath6kl_cfg80211_connect,
1813 .disconnect = ath6kl_cfg80211_disconnect,
1814 .add_key = ath6kl_cfg80211_add_key,
1815 .get_key = ath6kl_cfg80211_get_key,
1816 .del_key = ath6kl_cfg80211_del_key,
1817 .set_default_key = ath6kl_cfg80211_set_default_key,
1818 .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
1819 .set_tx_power = ath6kl_cfg80211_set_txpower,
1820 .get_tx_power = ath6kl_cfg80211_get_txpower,
1821 .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
1822 .join_ibss = ath6kl_cfg80211_join_ibss,
1823 .leave_ibss = ath6kl_cfg80211_leave_ibss,
1824 .get_station = ath6kl_get_station,
1825 .set_pmksa = ath6kl_set_pmksa,
1826 .del_pmksa = ath6kl_del_pmksa,
1827 .flush_pmksa = ath6kl_flush_pmksa,
1828 CFG80211_TESTMODE_CMD(ath6kl_tm_cmd)
1829 #ifdef CONFIG_PM
1830 .suspend = ar6k_cfg80211_suspend,
1831 #endif
1832 .set_channel = ath6kl_set_channel,
1833 .add_beacon = ath6kl_add_beacon,
1834 .set_beacon = ath6kl_set_beacon,
1835 .del_beacon = ath6kl_del_beacon,
1836 .change_station = ath6kl_change_station,
1837 .remain_on_channel = ath6kl_remain_on_channel,
1838 .cancel_remain_on_channel = ath6kl_cancel_remain_on_channel,
1839 .mgmt_tx = ath6kl_mgmt_tx,
1840 .mgmt_frame_register = ath6kl_mgmt_frame_register,
1841 };
1842
1843 struct wireless_dev *ath6kl_cfg80211_init(struct device *dev)
1844 {
1845 int ret = 0;
1846 struct wireless_dev *wdev;
1847 struct ath6kl *ar;
1848
1849 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
1850 if (!wdev) {
1851 ath6kl_err("couldn't allocate wireless device\n");
1852 return NULL;
1853 }
1854
1855 /* create a new wiphy for use with cfg80211 */
1856 wdev->wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
1857 if (!wdev->wiphy) {
1858 ath6kl_err("couldn't allocate wiphy device\n");
1859 kfree(wdev);
1860 return NULL;
1861 }
1862
1863 ar = wiphy_priv(wdev->wiphy);
1864 ar->p2p = !!ath6kl_p2p;
1865
1866 wdev->wiphy->mgmt_stypes = ath6kl_mgmt_stypes;
1867
1868 wdev->wiphy->max_remain_on_channel_duration = 5000;
1869
1870 /* set device pointer for wiphy */
1871 set_wiphy_dev(wdev->wiphy, dev);
1872
1873 wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1874 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
1875 if (ar->p2p) {
1876 wdev->wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_GO) |
1877 BIT(NL80211_IFTYPE_P2P_CLIENT);
1878 }
1879 /* max num of ssids that can be probed during scanning */
1880 wdev->wiphy->max_scan_ssids = MAX_PROBED_SSID_INDEX;
1881 wdev->wiphy->max_scan_ie_len = 1000; /* FIX: what is correct limit? */
1882 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
1883 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
1884 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
1885
1886 wdev->wiphy->cipher_suites = cipher_suites;
1887 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
1888
1889 ret = wiphy_register(wdev->wiphy);
1890 if (ret < 0) {
1891 ath6kl_err("couldn't register wiphy device\n");
1892 wiphy_free(wdev->wiphy);
1893 kfree(wdev);
1894 return NULL;
1895 }
1896
1897 return wdev;
1898 }
1899
1900 void ath6kl_cfg80211_deinit(struct ath6kl *ar)
1901 {
1902 struct wireless_dev *wdev = ar->wdev;
1903
1904 if (ar->scan_req) {
1905 cfg80211_scan_done(ar->scan_req, true);
1906 ar->scan_req = NULL;
1907 }
1908
1909 if (!wdev)
1910 return;
1911
1912 wiphy_unregister(wdev->wiphy);
1913 wiphy_free(wdev->wiphy);
1914 kfree(wdev);
1915 }
Linux kernel - Deliverables
This page took 0.070245 seconds and 6 git commands to generate.