projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ath6kl: fix crash when interface is closed but scan is ongoing
[deliverable/linux.git] / drivers / net / wireless / ath / ath6kl / cfg80211.c
CommitLineData
bdcd8170
KV		 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
21#define RATETAB_ENT(_rate, _rateid, _flags) { \
22 .bitrate = (_rate), \
23 .flags = (_flags), \
24 .hw_value = (_rateid), \
25}
26
27#define CHAN2G(_channel, _freq, _flags) { \
28 .band = IEEE80211_BAND_2GHZ, \
29 .hw_value = (_channel), \
30 .center_freq = (_freq), \
31 .flags = (_flags), \
32 .max_antenna_gain = 0, \
33 .max_power = 30, \
34}
35
36#define CHAN5G(_channel, _flags) { \
37 .band = IEEE80211_BAND_5GHZ, \
38 .hw_value = (_channel), \
39 .center_freq = 5000 + (5 * (_channel)), \
40 .flags = (_flags), \
41 .max_antenna_gain = 0, \
42 .max_power = 30, \
43}
44
45static struct ieee80211_rate ath6kl_rates[] = {
46 RATETAB_ENT(10, 0x1, 0),
47 RATETAB_ENT(20, 0x2, 0),
48 RATETAB_ENT(55, 0x4, 0),
49 RATETAB_ENT(110, 0x8, 0),
50 RATETAB_ENT(60, 0x10, 0),
51 RATETAB_ENT(90, 0x20, 0),
52 RATETAB_ENT(120, 0x40, 0),
53 RATETAB_ENT(180, 0x80, 0),
54 RATETAB_ENT(240, 0x100, 0),
55 RATETAB_ENT(360, 0x200, 0),
56 RATETAB_ENT(480, 0x400, 0),
57 RATETAB_ENT(540, 0x800, 0),
58};
59
60#define ath6kl_a_rates (ath6kl_rates + 4)
61#define ath6kl_a_rates_size 8
62#define ath6kl_g_rates (ath6kl_rates + 0)
63#define ath6kl_g_rates_size 12
64
65static struct ieee80211_channel ath6kl_2ghz_channels[] = {
66 CHAN2G(1, 2412, 0),
67 CHAN2G(2, 2417, 0),
68 CHAN2G(3, 2422, 0),
69 CHAN2G(4, 2427, 0),
70 CHAN2G(5, 2432, 0),
71 CHAN2G(6, 2437, 0),
72 CHAN2G(7, 2442, 0),
73 CHAN2G(8, 2447, 0),
74 CHAN2G(9, 2452, 0),
75 CHAN2G(10, 2457, 0),
76 CHAN2G(11, 2462, 0),
77 CHAN2G(12, 2467, 0),
78 CHAN2G(13, 2472, 0),
79 CHAN2G(14, 2484, 0),
80};
81
82static struct ieee80211_channel ath6kl_5ghz_a_channels[] = {
83 CHAN5G(34, 0), CHAN5G(36, 0),
84 CHAN5G(38, 0), CHAN5G(40, 0),
85 CHAN5G(42, 0), CHAN5G(44, 0),
86 CHAN5G(46, 0), CHAN5G(48, 0),
87 CHAN5G(52, 0), CHAN5G(56, 0),
88 CHAN5G(60, 0), CHAN5G(64, 0),
89 CHAN5G(100, 0), CHAN5G(104, 0),
90 CHAN5G(108, 0), CHAN5G(112, 0),
91 CHAN5G(116, 0), CHAN5G(120, 0),
92 CHAN5G(124, 0), CHAN5G(128, 0),
93 CHAN5G(132, 0), CHAN5G(136, 0),
94 CHAN5G(140, 0), CHAN5G(149, 0),
95 CHAN5G(153, 0), CHAN5G(157, 0),
96 CHAN5G(161, 0), CHAN5G(165, 0),
97 CHAN5G(184, 0), CHAN5G(188, 0),
98 CHAN5G(192, 0), CHAN5G(196, 0),
99 CHAN5G(200, 0), CHAN5G(204, 0),
100 CHAN5G(208, 0), CHAN5G(212, 0),
101 CHAN5G(216, 0),
102};
103
104static struct ieee80211_supported_band ath6kl_band_2ghz = {
105 .n_channels = ARRAY_SIZE(ath6kl_2ghz_channels),
106 .channels = ath6kl_2ghz_channels,
107 .n_bitrates = ath6kl_g_rates_size,
108 .bitrates = ath6kl_g_rates,
109};
110
111static struct ieee80211_supported_band ath6kl_band_5ghz = {
112 .n_channels = ARRAY_SIZE(ath6kl_5ghz_a_channels),
113 .channels = ath6kl_5ghz_a_channels,
114 .n_bitrates = ath6kl_a_rates_size,
115 .bitrates = ath6kl_a_rates,
116};
117
118static int ath6kl_set_wpa_version(struct ath6kl *ar,
119 enum nl80211_wpa_versions wpa_version)
120{
121 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: %u\n", __func__, wpa_version);
122
123 if (!wpa_version) {
124 ar->auth_mode = NONE_AUTH;
125 } else if (wpa_version & NL80211_WPA_VERSION_2) {
126 ar->auth_mode = WPA2_AUTH;
127 } else if (wpa_version & NL80211_WPA_VERSION_1) {
128 ar->auth_mode = WPA_AUTH;
129 } else {
130 ath6kl_err("%s: %u not supported\n", __func__, wpa_version);
131 return -ENOTSUPP;
132 }
133
134 return 0;
135}
136
137static int ath6kl_set_auth_type(struct ath6kl *ar,
138 enum nl80211_auth_type auth_type)
139{
140
141 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, auth_type);
142
143 switch (auth_type) {
144 case NL80211_AUTHTYPE_OPEN_SYSTEM:
145 ar->dot11_auth_mode = OPEN_AUTH;
146 break;
147 case NL80211_AUTHTYPE_SHARED_KEY:
148 ar->dot11_auth_mode = SHARED_AUTH;
149 break;
150 case NL80211_AUTHTYPE_NETWORK_EAP:
151 ar->dot11_auth_mode = LEAP_AUTH;
152 break;
153
154 case NL80211_AUTHTYPE_AUTOMATIC:
155 ar->dot11_auth_mode = OPEN_AUTH;
156 ar->auto_auth_stage = AUTH_OPEN_IN_PROGRESS;
157 break;
158
159 default:
160 ath6kl_err("%s: 0x%x not spported\n", __func__, auth_type);
161 return -ENOTSUPP;
162 }
163
164 return 0;
165}
166
167static int ath6kl_set_cipher(struct ath6kl *ar, u32 cipher, bool ucast)
168{
169 u8 *ar_cipher = ucast ? &ar->prwise_crypto : &ar->grp_crypto;
170 u8 *ar_cipher_len = ucast ? &ar->prwise_crypto_len : &ar->grp_crpto_len;
171
172 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: cipher 0x%x, ucast %u\n",
173 __func__, cipher, ucast);
174
175 switch (cipher) {
176 case 0:
177 /* our own hack to use value 0 as no crypto used */
178 *ar_cipher = NONE_CRYPT;
179 *ar_cipher_len = 0;
180 break;
181 case WLAN_CIPHER_SUITE_WEP40:
182 *ar_cipher = WEP_CRYPT;
183 *ar_cipher_len = 5;
184 break;
185 case WLAN_CIPHER_SUITE_WEP104:
186 *ar_cipher = WEP_CRYPT;
187 *ar_cipher_len = 13;
188 break;
189 case WLAN_CIPHER_SUITE_TKIP:
190 *ar_cipher = TKIP_CRYPT;
191 *ar_cipher_len = 0;
192 break;
193 case WLAN_CIPHER_SUITE_CCMP:
194 *ar_cipher = AES_CRYPT;
195 *ar_cipher_len = 0;
196 break;
197 default:
198 ath6kl_err("cipher 0x%x not supported\n", cipher);
199 return -ENOTSUPP;
200 }
201
202 return 0;
203}
204
205static void ath6kl_set_key_mgmt(struct ath6kl *ar, u32 key_mgmt)
206{
207 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: 0x%x\n", __func__, key_mgmt);
208
209 if (key_mgmt == WLAN_AKM_SUITE_PSK) {
210 if (ar->auth_mode == WPA_AUTH)
211 ar->auth_mode = WPA_PSK_AUTH;
212 else if (ar->auth_mode == WPA2_AUTH)
213 ar->auth_mode = WPA2_PSK_AUTH;
214 } else if (key_mgmt != WLAN_AKM_SUITE_8021X) {
215 ar->auth_mode = NONE_AUTH;
216 }
217}
218
219static bool ath6kl_cfg80211_ready(struct ath6kl *ar)
220{
221 if (!test_bit(WMI_READY, &ar->flag)) {
222 ath6kl_err("wmi is not ready\n");
223 return false;
224 }
225
575b5f34 226 if (!test_bit(WLAN_ENABLED, &ar->flag)) {
bdcd8170
KV		 227 ath6kl_err("wlan disabled\n");
228 return false;
229 }
230
231 return true;
232}
233
234static int ath6kl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
235 struct cfg80211_connect_params *sme)
236{
237 struct ath6kl *ar = ath6kl_priv(dev);
238 int status;
239
240 ar->sme_state = SME_CONNECTING;
241
242 if (!ath6kl_cfg80211_ready(ar))
243 return -EIO;
244
245 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
246 ath6kl_err("destroy in progress\n");
247 return -EBUSY;
248 }
249
250 if (test_bit(SKIP_SCAN, &ar->flag) &&
251 ((sme->channel && sme->channel->center_freq == 0) ||
252 (sme->bssid && is_zero_ether_addr(sme->bssid)))) {
253 ath6kl_err("SkipScan: channel or bssid invalid\n");
254 return -EINVAL;
255 }
256
257 if (down_interruptible(&ar->sem)) {
258 ath6kl_err("busy, couldn't get access\n");
259 return -ERESTARTSYS;
260 }
261
262 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
263 ath6kl_err("busy, destroy in progress\n");
264 up(&ar->sem);
265 return -EBUSY;
266 }
267
268 if (ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)]) {
269 /*
270 * sleep until the command queue drains
271 */
272 wait_event_interruptible_timeout(ar->event_wq,
273 ar->tx_pending[ath6kl_wmi_get_control_ep(ar->wmi)] == 0,
274 WMI_TIMEOUT);
275 if (signal_pending(current)) {
276 ath6kl_err("cmd queue drain timeout\n");
277 up(&ar->sem);
278 return -EINTR;
279 }
280 }
281
282 if (test_bit(CONNECTED, &ar->flag) &&
283 ar->ssid_len == sme->ssid_len &&
284 !memcmp(ar->ssid, sme->ssid, ar->ssid_len)) {
285 ar->reconnect_flag = true;
286 status = ath6kl_wmi_reconnect_cmd(ar->wmi, ar->req_bssid,
287 ar->ch_hint);
288
289 up(&ar->sem);
290 if (status) {
291 ath6kl_err("wmi_reconnect_cmd failed\n");
292 return -EIO;
293 }
294 return 0;
295 } else if (ar->ssid_len == sme->ssid_len &&
296 !memcmp(ar->ssid, sme->ssid, ar->ssid_len)) {
297 ath6kl_disconnect(ar);
298 }
299
300 memset(ar->ssid, 0, sizeof(ar->ssid));
301 ar->ssid_len = sme->ssid_len;
302 memcpy(ar->ssid, sme->ssid, sme->ssid_len);
303
304 if (sme->channel)
305 ar->ch_hint = sme->channel->center_freq;
306
307 memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
308 if (sme->bssid && !is_broadcast_ether_addr(sme->bssid))
309 memcpy(ar->req_bssid, sme->bssid, sizeof(ar->req_bssid));
310
311 ath6kl_set_wpa_version(ar, sme->crypto.wpa_versions);
312
313 status = ath6kl_set_auth_type(ar, sme->auth_type);
314 if (status) {
315 up(&ar->sem);
316 return status;
317 }
318
319 if (sme->crypto.n_ciphers_pairwise)
320 ath6kl_set_cipher(ar, sme->crypto.ciphers_pairwise[0], true);
321 else
322 ath6kl_set_cipher(ar, 0, true);
323
324 ath6kl_set_cipher(ar, sme->crypto.cipher_group, false);
325
326 if (sme->crypto.n_akm_suites)
327 ath6kl_set_key_mgmt(ar, sme->crypto.akm_suites[0]);
328
329 if ((sme->key_len) &&
330 (ar->auth_mode == NONE_AUTH) && (ar->prwise_crypto == WEP_CRYPT)) {
331 struct ath6kl_key *key = NULL;
332
333 if (sme->key_idx < WMI_MIN_KEY_INDEX ||
334 sme->key_idx > WMI_MAX_KEY_INDEX) {
335 ath6kl_err("key index %d out of bounds\n",
336 sme->key_idx);
337 up(&ar->sem);
338 return -ENOENT;
339 }
340
341 key = &ar->keys[sme->key_idx];
342 key->key_len = sme->key_len;
343 memcpy(key->key, sme->key, key->key_len);
344 key->cipher = ar->prwise_crypto;
345 ar->def_txkey_index = sme->key_idx;
346
347 ath6kl_wmi_addkey_cmd(ar->wmi, sme->key_idx,
348 ar->prwise_crypto,
349 GROUP_USAGE | TX_USAGE,
350 key->key_len,
351 NULL,
352 key->key, KEY_OP_INIT_VAL, NULL,
353 NO_SYNC_WMIFLAG);
354 }
355
356 if (!ar->usr_bss_filter) {
357 if (ath6kl_wmi_bssfilter_cmd(ar->wmi, ALL_BSS_FILTER, 0) != 0) {
358 ath6kl_err("couldn't set bss filtering\n");
359 up(&ar->sem);
360 return -EIO;
361 }
362 }
363
364 ar->nw_type = ar->next_mode;
365
366 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
367 "%s: connect called with authmode %d dot11 auth %d"
368 " PW crypto %d PW crypto len %d GRP crypto %d"
369 " GRP crypto len %d channel hint %u\n",
370 __func__,
371 ar->auth_mode, ar->dot11_auth_mode, ar->prwise_crypto,
372 ar->prwise_crypto_len, ar->grp_crypto,
373 ar->grp_crpto_len, ar->ch_hint);
374
375 ar->reconnect_flag = 0;
376 status = ath6kl_wmi_connect_cmd(ar->wmi, ar->nw_type,
377 ar->dot11_auth_mode, ar->auth_mode,
378 ar->prwise_crypto,
379 ar->prwise_crypto_len,
380 ar->grp_crypto, ar->grp_crpto_len,
381 ar->ssid_len, ar->ssid,
382 ar->req_bssid, ar->ch_hint,
383 ar->connect_ctrl_flags);
384
385 up(&ar->sem);
386
387 if (status == -EINVAL) {
388 memset(ar->ssid, 0, sizeof(ar->ssid));
389 ar->ssid_len = 0;
390 ath6kl_err("invalid request\n");
391 return -ENOENT;
392 } else if (status) {
393 ath6kl_err("ath6kl_wmi_connect_cmd failed\n");
394 return -EIO;
395 }
396
397 if ((!(ar->connect_ctrl_flags & CONNECT_DO_WPA_OFFLOAD)) &&
398 ((ar->auth_mode == WPA_PSK_AUTH)
399 || (ar->auth_mode == WPA2_PSK_AUTH))) {
400 mod_timer(&ar->disconnect_timer,
401 jiffies + msecs_to_jiffies(DISCON_TIMER_INTVAL));
402 }
403
404 ar->connect_ctrl_flags &= ~CONNECT_DO_WPA_OFFLOAD;
405 set_bit(CONNECT_PEND, &ar->flag);
406
407 return 0;
408}
409
410void ath6kl_cfg80211_connect_event(struct ath6kl *ar, u16 channel,
411 u8 *bssid, u16 listen_intvl,
412 u16 beacon_intvl,
413 enum network_type nw_type,
414 u8 beacon_ie_len, u8 assoc_req_len,
415 u8 assoc_resp_len, u8 *assoc_info)
416{
417 u16 size = 0;
418 u16 capability = 0;
419 struct cfg80211_bss *bss = NULL;
420 struct ieee80211_mgmt *mgmt = NULL;
421 struct ieee80211_channel *ibss_ch = NULL;
422 s32 signal = 50 * 100;
423 u8 ie_buf_len = 0;
424 unsigned char ie_buf[256];
425 unsigned char *ptr_ie_buf = ie_buf;
426 unsigned char *ieeemgmtbuf = NULL;
427 u8 source_mac[ETH_ALEN];
428 u16 capa_mask;
429 u16 capa_val;
430
431 /* capinfo + listen interval */
432 u8 assoc_req_ie_offset = sizeof(u16) + sizeof(u16);
433
434 /* capinfo + status code + associd */
435 u8 assoc_resp_ie_offset = sizeof(u16) + sizeof(u16) + sizeof(u16);
436
437 u8 *assoc_req_ie = assoc_info + beacon_ie_len + assoc_req_ie_offset;
438 u8 *assoc_resp_ie = assoc_info + beacon_ie_len + assoc_req_len +
439 assoc_resp_ie_offset;
440
441 assoc_req_len -= assoc_req_ie_offset;
442 assoc_resp_len -= assoc_resp_ie_offset;
443
444 ar->auto_auth_stage = AUTH_IDLE;
445
446 if (nw_type & ADHOC_NETWORK) {
447 if (ar->wdev->iftype != NL80211_IFTYPE_ADHOC) {
448 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
449 "%s: ath6k not in ibss mode\n", __func__);
450 return;
451 }
452 }
453
454 if (nw_type & INFRA_NETWORK) {
455 if (ar->wdev->iftype != NL80211_IFTYPE_STATION) {
456 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
457 "%s: ath6k not in station mode\n", __func__);
458 return;
459 }
460 }
461
462 if (nw_type & ADHOC_NETWORK) {
463 capa_mask = WLAN_CAPABILITY_IBSS;
464 capa_val = WLAN_CAPABILITY_IBSS;
465 } else {
466 capa_mask = WLAN_CAPABILITY_ESS;
467 capa_val = WLAN_CAPABILITY_ESS;
468 }
469
470 /* Before informing the join/connect event, make sure that
471 * bss entry is present in scan list, if it not present
472 * construct and insert into scan list, otherwise that
473 * event will be dropped on the way by cfg80211, due to
474 * this keys will not be plumbed in case of WEP and
475 * application will not be aware of join/connect status. */
476 bss = cfg80211_get_bss(ar->wdev->wiphy, NULL, bssid,
477 ar->wdev->ssid, ar->wdev->ssid_len,
478 capa_mask, capa_val);
479
480 /*
481 * Earlier we were updating the cfg about bss by making a beacon frame
482 * only if the entry for bss is not there. This can have some issue if
483 * ROAM event is generated and a heavy traffic is ongoing. The ROAM
484 * event is handled through a work queue and by the time it really gets
485 * handled, BSS would have been aged out. So it is better to update the
486 * cfg about BSS irrespective of its entry being present right now or
487 * not.
488 */
489
490 if (nw_type & ADHOC_NETWORK) {
491 /* construct 802.11 mgmt beacon */
492 if (ptr_ie_buf) {
493 *ptr_ie_buf++ = WLAN_EID_SSID;
494 *ptr_ie_buf++ = ar->ssid_len;
495 memcpy(ptr_ie_buf, ar->ssid, ar->ssid_len);
496 ptr_ie_buf += ar->ssid_len;
497
498 *ptr_ie_buf++ = WLAN_EID_IBSS_PARAMS;
499 *ptr_ie_buf++ = 2; /* length */
500 *ptr_ie_buf++ = 0; /* ATIM window */
501 *ptr_ie_buf++ = 0; /* ATIM window */
502
503 /* TODO: update ibss params and include supported rates,
504 * DS param set, extened support rates, wmm. */
505
506 ie_buf_len = ptr_ie_buf - ie_buf;
507 }
508
509 capability |= WLAN_CAPABILITY_IBSS;
510
511 if (ar->prwise_crypto == WEP_CRYPT)
512 capability |= WLAN_CAPABILITY_PRIVACY;
513
514 memcpy(source_mac, ar->net_dev->dev_addr, ETH_ALEN);
515 ptr_ie_buf = ie_buf;
516 } else {
517 capability = *(u16 *) (&assoc_info[beacon_ie_len]);
518 memcpy(source_mac, bssid, ETH_ALEN);
519 ptr_ie_buf = assoc_req_ie;
520 ie_buf_len = assoc_req_len;
521 }
522
523 size = offsetof(struct ieee80211_mgmt, u)
524 + sizeof(mgmt->u.beacon)
525 + ie_buf_len;
526
527 ieeemgmtbuf = kzalloc(size, GFP_ATOMIC);
528 if (!ieeemgmtbuf) {
529 ath6kl_err("ieee mgmt buf alloc error\n");
530 cfg80211_put_bss(bss);
531 return;
532 }
533
534 mgmt = (struct ieee80211_mgmt *)ieeemgmtbuf;
535 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
536 IEEE80211_STYPE_BEACON);
537 memset(mgmt->da, 0xff, ETH_ALEN); /* broadcast addr */
538 memcpy(mgmt->sa, source_mac, ETH_ALEN);
539 memcpy(mgmt->bssid, bssid, ETH_ALEN);
540 mgmt->u.beacon.beacon_int = cpu_to_le16(beacon_intvl);
541 mgmt->u.beacon.capab_info = cpu_to_le16(capability);
542 memcpy(mgmt->u.beacon.variable, ptr_ie_buf, ie_buf_len);
543
544 ibss_ch = ieee80211_get_channel(ar->wdev->wiphy, (int)channel);
545
546 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
547 "%s: inform bss with bssid %pM channel %d beacon_intvl %d capability 0x%x\n",
548 __func__, mgmt->bssid, ibss_ch->hw_value,
549 beacon_intvl, capability);
550
551 bss = cfg80211_inform_bss_frame(ar->wdev->wiphy,
552 ibss_ch, mgmt,
553 size, signal, GFP_KERNEL);
554 kfree(ieeemgmtbuf);
555 cfg80211_put_bss(bss);
556
557 if (nw_type & ADHOC_NETWORK) {
558 cfg80211_ibss_joined(ar->net_dev, bssid, GFP_KERNEL);
559 return;
560 }
561
562 if (!test_bit(CONNECTED, &ar->flag)) {
563 /* inform connect result to cfg80211 */
564 ar->sme_state = SME_DISCONNECTED;
565 cfg80211_connect_result(ar->net_dev, bssid,
566 assoc_req_ie, assoc_req_len,
567 assoc_resp_ie, assoc_resp_len,
568 WLAN_STATUS_SUCCESS, GFP_KERNEL);
569 } else {
570 /* inform roam event to cfg80211 */
571 cfg80211_roamed(ar->net_dev, ibss_ch, bssid,
572 assoc_req_ie, assoc_req_len,
573 assoc_resp_ie, assoc_resp_len, GFP_KERNEL);
574 }
575}
576
577static int ath6kl_cfg80211_disconnect(struct wiphy *wiphy,
578 struct net_device *dev, u16 reason_code)
579{
580 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(dev);
581
582 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: reason=%u\n", __func__,
583 reason_code);
584
585 if (!ath6kl_cfg80211_ready(ar))
586 return -EIO;
587
588 if (test_bit(DESTROY_IN_PROGRESS, &ar->flag)) {
589 ath6kl_err("busy, destroy in progress\n");
590 return -EBUSY;
591 }
592
593 if (down_interruptible(&ar->sem)) {
594 ath6kl_err("busy, couldn't get access\n");
595 return -ERESTARTSYS;
596 }
597
598 ar->reconnect_flag = 0;
599 ath6kl_disconnect(ar);
600 memset(ar->ssid, 0, sizeof(ar->ssid));
601 ar->ssid_len = 0;
602
603 if (!test_bit(SKIP_SCAN, &ar->flag))
604 memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
605
606 up(&ar->sem);
607
608 return 0;
609}
610
611void ath6kl_cfg80211_disconnect_event(struct ath6kl *ar, u8 reason,
612 u8 *bssid, u8 assoc_resp_len,
613 u8 *assoc_info, u16 proto_reason)
614{
615 struct ath6kl_key *key = NULL;
616 u16 status;
617
618 if (ar->scan_req) {
619 cfg80211_scan_done(ar->scan_req, true);
620 ar->scan_req = NULL;
621 }
622
623 if (ar->nw_type & ADHOC_NETWORK) {
624 if (ar->wdev->iftype != NL80211_IFTYPE_ADHOC) {
625 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
626 "%s: ath6k not in ibss mode\n", __func__);
627 return;
628 }
629 memset(bssid, 0, ETH_ALEN);
630 cfg80211_ibss_joined(ar->net_dev, bssid, GFP_KERNEL);
631 return;
632 }
633
634 if (ar->nw_type & INFRA_NETWORK) {
635 if (ar->wdev->iftype != NL80211_IFTYPE_STATION) {
636 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
637 "%s: ath6k not in station mode\n", __func__);
638 return;
639 }
640 }
641
642 if (!test_bit(CONNECT_PEND, &ar->flag)) {
643 if (reason != DISCONNECT_CMD)
644 ath6kl_wmi_disconnect_cmd(ar->wmi);
645
646 return;
647 }
648
649 if (reason == NO_NETWORK_AVAIL) {
650 /* connect cmd failed */
651 ath6kl_wmi_disconnect_cmd(ar->wmi);
652 return;
653 }
654
655 if (reason != DISCONNECT_CMD)
656 return;
657
658 if (!ar->auto_auth_stage) {
659 clear_bit(CONNECT_PEND, &ar->flag);
660
661 if (ar->sme_state == SME_CONNECTING) {
662 cfg80211_connect_result(ar->net_dev,
663 bssid, NULL, 0,
664 NULL, 0,
665 WLAN_STATUS_UNSPECIFIED_FAILURE,
666 GFP_KERNEL);
667 } else {
668 cfg80211_disconnected(ar->net_dev, reason,
669 NULL, 0, GFP_KERNEL);
670 }
671
672 ar->sme_state = SME_DISCONNECTED;
673 return;
674 }
675
676 if (ar->dot11_auth_mode != OPEN_AUTH)
677 return;
678
679 /*
680 * If the current auth algorithm is open, try shared and
681 * make autoAuthStage idle. We do not make it leap for now
682 * being.
683 */
684 key = &ar->keys[ar->def_txkey_index];
685 if (down_interruptible(&ar->sem)) {
686 ath6kl_err("busy, couldn't get access\n");
687 return;
688 }
689
690 ar->dot11_auth_mode = SHARED_AUTH;
691 ar->auto_auth_stage = AUTH_IDLE;
692
693 ath6kl_wmi_addkey_cmd(ar->wmi,
694 ar->def_txkey_index,
695 ar->prwise_crypto,
696 GROUP_USAGE | TX_USAGE,
697 key->key_len, NULL,
698 key->key,
699 KEY_OP_INIT_VAL, NULL,
700 NO_SYNC_WMIFLAG);
701
702 status = ath6kl_wmi_connect_cmd(ar->wmi,
703 ar->nw_type,
704 ar->dot11_auth_mode,
705 ar->auth_mode,
706 ar->prwise_crypto,
707 ar->prwise_crypto_len,
708 ar->grp_crypto,
709 ar->grp_crpto_len,
710 ar->ssid_len,
711 ar->ssid,
712 ar->req_bssid,
713 ar->ch_hint,
714 ar->connect_ctrl_flags);
715 up(&ar->sem);
716}
717
718static inline bool is_ch_11a(u16 ch)
719{
720 return (!((ch >= 2412) && (ch <= 2484)));
721}
722
cf104c2a 723/* struct ath6kl_node_table::nt_nodelock is locked when calling this */
bdcd8170
KV		 724static void ath6kl_cfg80211_scan_node(void *arg, struct bss *ni)
725{
726 struct wiphy *wiphy = (struct wiphy *)arg;
727 u16 size;
728 unsigned char *ieeemgmtbuf = NULL;
729 struct ieee80211_mgmt *mgmt;
730 struct ieee80211_channel *channel;
731 struct ieee80211_supported_band *band;
732 struct ath6kl_common_ie *cie;
733 s32 signal;
734 int freq;
735
736 cie = &ni->ni_cie;
737
738 if (is_ch_11a(cie->ie_chan))
739 band = wiphy->bands[IEEE80211_BAND_5GHZ]; /* 11a */
740 else if ((cie->ie_erp) || (cie->ie_xrates))
741 band = wiphy->bands[IEEE80211_BAND_2GHZ]; /* 11g */
742 else
743 band = wiphy->bands[IEEE80211_BAND_2GHZ]; /* 11b */
744
745 size = ni->ni_framelen + offsetof(struct ieee80211_mgmt, u);
746 ieeemgmtbuf = kmalloc(size, GFP_ATOMIC);
747 if (!ieeemgmtbuf) {
748 ath6kl_err("ieee mgmt buf alloc error\n");
749 return;
750 }
751
752 /*
753 * TODO: Update target to include 802.11 mac header while sending
754 * bss info. Target removes 802.11 mac header while sending the bss
755 * info to host, cfg80211 needs it, for time being just filling the
756 * da, sa and bssid fields alone.
757 */
758 mgmt = (struct ieee80211_mgmt *)ieeemgmtbuf;
759 memset(mgmt->da, 0xff, ETH_ALEN); /*broadcast addr */
760 memcpy(mgmt->sa, ni->ni_macaddr, ETH_ALEN);
761 memcpy(mgmt->bssid, ni->ni_macaddr, ETH_ALEN);
762 memcpy(ieeemgmtbuf + offsetof(struct ieee80211_mgmt, u),
763 ni->ni_buf, ni->ni_framelen);
764
765 freq = cie->ie_chan;
766 channel = ieee80211_get_channel(wiphy, freq);
767 signal = ni->ni_snr * 100;
768
769 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
770 "%s: bssid %pM ch %d freq %d size %d\n", __func__,
771 mgmt->bssid, channel->hw_value, freq, size);
772 cfg80211_inform_bss_frame(wiphy, channel, mgmt,
cf104c2a 773 size, signal, GFP_ATOMIC);
bdcd8170
KV		 774
775 kfree(ieeemgmtbuf);
776}
777
778static int ath6kl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
779 struct cfg80211_scan_request *request)
780{
781 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
782 int ret = 0;
bdcd8170
KV		 783
784 if (!ath6kl_cfg80211_ready(ar))
785 return -EIO;
786
787 if (!ar->usr_bss_filter) {
788 if (ath6kl_wmi_bssfilter_cmd(ar->wmi,
789 (test_bit(CONNECTED, &ar->flag) ?
790 ALL_BUT_BSS_FILTER :
791 ALL_BSS_FILTER), 0) != 0) {
792 ath6kl_err("couldn't set bss filtering\n");
793 return -EIO;
794 }
795 }
796
797 if (request->n_ssids && request->ssids[0].ssid_len) {
798 u8 i;
799
800 if (request->n_ssids > (MAX_PROBED_SSID_INDEX - 1))
801 request->n_ssids = MAX_PROBED_SSID_INDEX - 1;
802
803 for (i = 0; i < request->n_ssids; i++)
804 ath6kl_wmi_probedssid_cmd(ar->wmi, i + 1,
805 SPECIFIC_SSID_FLAG,
806 request->ssids[i].ssid_len,
807 request->ssids[i].ssid);
808 }
809
b2c76bbe 810 if (ath6kl_wmi_startscan_cmd(ar->wmi, WMI_LONG_SCAN, 0,
bdcd8170
KV		 811 false, 0, 0, 0, NULL) != 0) {
812 ath6kl_err("wmi_startscan_cmd failed\n");
813 ret = -EIO;
814 }
815
816 ar->scan_req = request;
817
818 return ret;
819}
820
821void ath6kl_cfg80211_scan_complete_event(struct ath6kl *ar, int status)
822{
6fd1eace 823 int i;
bdcd8170
KV		 824
825 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: status %d\n", __func__, status);
826
6fd1eace
KV		 827 if (!ar->scan_req)
828 return;
829
830 if ((status == -ECANCELED) || (status == -EBUSY)) {
831 cfg80211_scan_done(ar->scan_req, true);
832 goto out;
833 }
834
835 /* Translate data to cfg80211 mgmt format */
836 ath6kl_wmi_iterate_nodes(ar->wmi, ath6kl_cfg80211_scan_node,
837 ar->wdev->wiphy);
838
839 cfg80211_scan_done(ar->scan_req, false);
840
841 if (ar->scan_req->n_ssids && ar->scan_req->ssids[0].ssid_len) {
842 for (i = 0; i < ar->scan_req->n_ssids; i++) {
843 ath6kl_wmi_probedssid_cmd(ar->wmi, i + 1,
844 DISABLE_SSID_FLAG,
845 0, NULL);
bdcd8170 846 }
bdcd8170 847 }
6fd1eace
KV		 848
849out:
850 ar->scan_req = NULL;
bdcd8170
KV		 851}
852
853static int ath6kl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
854 u8 key_index, bool pairwise,
855 const u8 *mac_addr,
856 struct key_params *params)
857{
858 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
859 struct ath6kl_key *key = NULL;
860 u8 key_usage;
861 u8 key_type;
862 int status = 0;
863
864 if (!ath6kl_cfg80211_ready(ar))
865 return -EIO;
866
867 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
868 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
869 "%s: key index %d out of bounds\n", __func__,
870 key_index);
871 return -ENOENT;
872 }
873
874 key = &ar->keys[key_index];
875 memset(key, 0, sizeof(struct ath6kl_key));
876
877 if (pairwise)
878 key_usage = PAIRWISE_USAGE;
879 else
880 key_usage = GROUP_USAGE;
881
882 if (params) {
883 if (params->key_len > WLAN_MAX_KEY_LEN ||
884 params->seq_len > sizeof(key->seq))
885 return -EINVAL;
886
887 key->key_len = params->key_len;
888 memcpy(key->key, params->key, key->key_len);
889 key->seq_len = params->seq_len;
890 memcpy(key->seq, params->seq, key->seq_len);
891 key->cipher = params->cipher;
892 }
893
894 switch (key->cipher) {
895 case WLAN_CIPHER_SUITE_WEP40:
896 case WLAN_CIPHER_SUITE_WEP104:
897 key_type = WEP_CRYPT;
898 break;
899
900 case WLAN_CIPHER_SUITE_TKIP:
901 key_type = TKIP_CRYPT;
902 break;
903
904 case WLAN_CIPHER_SUITE_CCMP:
905 key_type = AES_CRYPT;
906 break;
907
908 default:
909 return -ENOTSUPP;
910 }
911
912 if (((ar->auth_mode == WPA_PSK_AUTH)
913 || (ar->auth_mode == WPA2_PSK_AUTH))
914 && (key_usage & GROUP_USAGE))
915 del_timer(&ar->disconnect_timer);
916
917 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
918 "%s: index %d, key_len %d, key_type 0x%x, key_usage 0x%x, seq_len %d\n",
919 __func__, key_index, key->key_len, key_type,
920 key_usage, key->seq_len);
921
922 ar->def_txkey_index = key_index;
923 status = ath6kl_wmi_addkey_cmd(ar->wmi, ar->def_txkey_index,
924 key_type, key_usage, key->key_len,
925 key->seq, key->key, KEY_OP_INIT_VAL,
926 (u8 *) mac_addr, SYNC_BOTH_WMIFLAG);
927
928 if (status)
929 return -EIO;
930
931 return 0;
932}
933
934static int ath6kl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
935 u8 key_index, bool pairwise,
936 const u8 *mac_addr)
937{
938 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
939
940 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
941
942 if (!ath6kl_cfg80211_ready(ar))
943 return -EIO;
944
945 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
946 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
947 "%s: key index %d out of bounds\n", __func__,
948 key_index);
949 return -ENOENT;
950 }
951
952 if (!ar->keys[key_index].key_len) {
953 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
954 "%s: index %d is empty\n", __func__, key_index);
955 return 0;
956 }
957
958 ar->keys[key_index].key_len = 0;
959
960 return ath6kl_wmi_deletekey_cmd(ar->wmi, key_index);
961}
962
963static int ath6kl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
964 u8 key_index, bool pairwise,
965 const u8 *mac_addr, void *cookie,
966 void (*callback) (void *cookie,
967 struct key_params *))
968{
969 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
970 struct ath6kl_key *key = NULL;
971 struct key_params params;
972
973 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
974
975 if (!ath6kl_cfg80211_ready(ar))
976 return -EIO;
977
978 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
979 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
980 "%s: key index %d out of bounds\n", __func__,
981 key_index);
982 return -ENOENT;
983 }
984
985 key = &ar->keys[key_index];
986 memset(&params, 0, sizeof(params));
987 params.cipher = key->cipher;
988 params.key_len = key->key_len;
989 params.seq_len = key->seq_len;
990 params.seq = key->seq;
991 params.key = key->key;
992
993 callback(cookie, &params);
994
995 return key->key_len ? 0 : -ENOENT;
996}
997
998static int ath6kl_cfg80211_set_default_key(struct wiphy *wiphy,
999 struct net_device *ndev,
1000 u8 key_index, bool unicast,
1001 bool multicast)
1002{
1003 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(ndev);
1004 struct ath6kl_key *key = NULL;
1005 int status = 0;
1006 u8 key_usage;
1007
1008 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: index %d\n", __func__, key_index);
1009
1010 if (!ath6kl_cfg80211_ready(ar))
1011 return -EIO;
1012
1013 if (key_index < WMI_MIN_KEY_INDEX || key_index > WMI_MAX_KEY_INDEX) {
1014 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1015 "%s: key index %d out of bounds\n",
1016 __func__, key_index);
1017 return -ENOENT;
1018 }
1019
1020 if (!ar->keys[key_index].key_len) {
1021 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: invalid key index %d\n",
1022 __func__, key_index);
1023 return -EINVAL;
1024 }
1025
1026 ar->def_txkey_index = key_index;
1027 key = &ar->keys[ar->def_txkey_index];
1028 key_usage = GROUP_USAGE;
1029 if (ar->prwise_crypto == WEP_CRYPT)
1030 key_usage |= TX_USAGE;
1031
1032 status = ath6kl_wmi_addkey_cmd(ar->wmi, ar->def_txkey_index,
1033 ar->prwise_crypto, key_usage,
1034 key->key_len, key->seq, key->key,
1035 KEY_OP_INIT_VAL, NULL,
1036 SYNC_BOTH_WMIFLAG);
1037 if (status)
1038 return -EIO;
1039
1040 return 0;
1041}
1042
1043void ath6kl_cfg80211_tkip_micerr_event(struct ath6kl *ar, u8 keyid,
1044 bool ismcast)
1045{
1046 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1047 "%s: keyid %d, ismcast %d\n", __func__, keyid, ismcast);
1048
1049 cfg80211_michael_mic_failure(ar->net_dev, ar->bssid,
1050 (ismcast ? NL80211_KEYTYPE_GROUP :
1051 NL80211_KEYTYPE_PAIRWISE), keyid, NULL,
1052 GFP_KERNEL);
1053}
1054
1055static int ath6kl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1056{
1057 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1058 int ret;
1059
1060 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: changed 0x%x\n", __func__,
1061 changed);
1062
1063 if (!ath6kl_cfg80211_ready(ar))
1064 return -EIO;
1065
1066 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1067 ret = ath6kl_wmi_set_rts_cmd(ar->wmi, wiphy->rts_threshold);
1068 if (ret != 0) {
1069 ath6kl_err("ath6kl_wmi_set_rts_cmd failed\n");
1070 return -EIO;
1071 }
1072 }
1073
1074 return 0;
1075}
1076
1077/*
1078 * The type nl80211_tx_power_setting replaces the following
1079 * data type from 2.6.36 onwards
1080*/
1081static int ath6kl_cfg80211_set_txpower(struct wiphy *wiphy,
1082 enum nl80211_tx_power_setting type,
1083 int dbm)
1084{
1085 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1086 u8 ath6kl_dbm;
1087
1088 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x, dbm %d\n", __func__,
1089 type, dbm);
1090
1091 if (!ath6kl_cfg80211_ready(ar))
1092 return -EIO;
1093
1094 switch (type) {
1095 case NL80211_TX_POWER_AUTOMATIC:
1096 return 0;
1097 case NL80211_TX_POWER_LIMITED:
1098 ar->tx_pwr = ath6kl_dbm = dbm;
1099 break;
1100 default:
1101 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type 0x%x not supported\n",
1102 __func__, type);
1103 return -EOPNOTSUPP;
1104 }
1105
1106 ath6kl_wmi_set_tx_pwr_cmd(ar->wmi, ath6kl_dbm);
1107
1108 return 0;
1109}
1110
1111static int ath6kl_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm)
1112{
1113 struct ath6kl *ar = (struct ath6kl *)wiphy_priv(wiphy);
1114
1115 if (!ath6kl_cfg80211_ready(ar))
1116 return -EIO;
1117
1118 if (test_bit(CONNECTED, &ar->flag)) {
1119 ar->tx_pwr = 0;
1120
1121 if (ath6kl_wmi_get_tx_pwr_cmd(ar->wmi) != 0) {
1122 ath6kl_err("ath6kl_wmi_get_tx_pwr_cmd failed\n");
1123 return -EIO;
1124 }
1125
1126 wait_event_interruptible_timeout(ar->event_wq, ar->tx_pwr != 0,
1127 5 * HZ);
1128
1129 if (signal_pending(current)) {
1130 ath6kl_err("target did not respond\n");
1131 return -EINTR;
1132 }
1133 }
1134
1135 *dbm = ar->tx_pwr;
1136 return 0;
1137}
1138
1139static int ath6kl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
1140 struct net_device *dev,
1141 bool pmgmt, int timeout)
1142{
1143 struct ath6kl *ar = ath6kl_priv(dev);
1144 struct wmi_power_mode_cmd mode;
1145
1146 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: pmgmt %d, timeout %d\n",
1147 __func__, pmgmt, timeout);
1148
1149 if (!ath6kl_cfg80211_ready(ar))
1150 return -EIO;
1151
1152 if (pmgmt) {
1153 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: max perf\n", __func__);
1154 mode.pwr_mode = REC_POWER;
1155 } else {
1156 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: rec power\n", __func__);
1157 mode.pwr_mode = MAX_PERF_POWER;
1158 }
1159
1160 if (ath6kl_wmi_powermode_cmd(ar->wmi, mode.pwr_mode) != 0) {
1161 ath6kl_err("wmi_powermode_cmd failed\n");
1162 return -EIO;
1163 }
1164
1165 return 0;
1166}
1167
1168static int ath6kl_cfg80211_change_iface(struct wiphy *wiphy,
1169 struct net_device *ndev,
1170 enum nl80211_iftype type, u32 *flags,
1171 struct vif_params *params)
1172{
1173 struct ath6kl *ar = ath6kl_priv(ndev);
1174 struct wireless_dev *wdev = ar->wdev;
1175
1176 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG, "%s: type %u\n", __func__, type);
1177
1178 if (!ath6kl_cfg80211_ready(ar))
1179 return -EIO;
1180
1181 switch (type) {
1182 case NL80211_IFTYPE_STATION:
1183 ar->next_mode = INFRA_NETWORK;
1184 break;
1185 case NL80211_IFTYPE_ADHOC:
1186 ar->next_mode = ADHOC_NETWORK;
1187 break;
1188 default:
1189 ath6kl_err("invalid interface type %u\n", type);
1190 return -EOPNOTSUPP;
1191 }
1192
1193 wdev->iftype = type;
1194
1195 return 0;
1196}
1197
1198static int ath6kl_cfg80211_join_ibss(struct wiphy *wiphy,
1199 struct net_device *dev,
1200 struct cfg80211_ibss_params *ibss_param)
1201{
1202 struct ath6kl *ar = ath6kl_priv(dev);
1203 int status;
1204
1205 if (!ath6kl_cfg80211_ready(ar))
1206 return -EIO;
1207
1208 ar->ssid_len = ibss_param->ssid_len;
1209 memcpy(ar->ssid, ibss_param->ssid, ar->ssid_len);
1210
1211 if (ibss_param->channel)
1212 ar->ch_hint = ibss_param->channel->center_freq;
1213
1214 if (ibss_param->channel_fixed) {
1215 /*
1216 * TODO: channel_fixed: The channel should be fixed, do not
1217 * search for IBSSs to join on other channels. Target
1218 * firmware does not support this feature, needs to be
1219 * updated.
1220 */
1221 return -EOPNOTSUPP;
1222 }
1223
1224 memset(ar->req_bssid, 0, sizeof(ar->req_bssid));
1225 if (ibss_param->bssid && !is_broadcast_ether_addr(ibss_param->bssid))
1226 memcpy(ar->req_bssid, ibss_param->bssid, sizeof(ar->req_bssid));
1227
1228 ath6kl_set_wpa_version(ar, 0);
1229
1230 status = ath6kl_set_auth_type(ar, NL80211_AUTHTYPE_OPEN_SYSTEM);
1231 if (status)
1232 return status;
1233
1234 if (ibss_param->privacy) {
1235 ath6kl_set_cipher(ar, WLAN_CIPHER_SUITE_WEP40, true);
1236 ath6kl_set_cipher(ar, WLAN_CIPHER_SUITE_WEP40, false);
1237 } else {
1238 ath6kl_set_cipher(ar, 0, true);
1239 ath6kl_set_cipher(ar, 0, false);
1240 }
1241
1242 ar->nw_type = ar->next_mode;
1243
1244 ath6kl_dbg(ATH6KL_DBG_WLAN_CFG,
1245 "%s: connect called with authmode %d dot11 auth %d"
1246 " PW crypto %d PW crypto len %d GRP crypto %d"
1247 " GRP crypto len %d channel hint %u\n",
1248 __func__,
1249 ar->auth_mode, ar->dot11_auth_mode, ar->prwise_crypto,
1250 ar->prwise_crypto_len, ar->grp_crypto,
1251 ar->grp_crpto_len, ar->ch_hint);
1252
1253 status = ath6kl_wmi_connect_cmd(ar->wmi, ar->nw_type,
1254 ar->dot11_auth_mode, ar->auth_mode,
1255 ar->prwise_crypto,
1256 ar->prwise_crypto_len,
1257 ar->grp_crypto, ar->grp_crpto_len,
1258 ar->ssid_len, ar->ssid,
1259 ar->req_bssid, ar->ch_hint,
1260 ar->connect_ctrl_flags);
1261 set_bit(CONNECT_PEND, &ar->flag);
1262
1263 return 0;
1264}
1265
1266static int ath6kl_cfg80211_leave_ibss(struct wiphy *wiphy,
1267 struct net_device *dev)
1268{
1269 struct ath6kl *ar = (struct ath6kl *)ath6kl_priv(dev);
1270
1271 if (!ath6kl_cfg80211_ready(ar))
1272 return -EIO;
1273
1274 ath6kl_disconnect(ar);
1275 memset(ar->ssid, 0, sizeof(ar->ssid));
1276 ar->ssid_len = 0;
1277
1278 return 0;
1279}
1280
1281static const u32 cipher_suites[] = {
1282 WLAN_CIPHER_SUITE_WEP40,
1283 WLAN_CIPHER_SUITE_WEP104,
1284 WLAN_CIPHER_SUITE_TKIP,
1285 WLAN_CIPHER_SUITE_CCMP,
1286};
1287
1288static bool is_rate_legacy(s32 rate)
1289{
1290 static const s32 legacy[] = { 1000, 2000, 5500, 11000,
1291 6000, 9000, 12000, 18000, 24000,
1292 36000, 48000, 54000
1293 };
1294 u8 i;
1295
1296 for (i = 0; i < ARRAY_SIZE(legacy); i++)
1297 if (rate == legacy[i])
1298 return true;
1299
1300 return false;
1301}
1302
1303static bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
1304{
1305 static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
1306 52000, 58500, 65000, 72200
1307 };
1308 u8 i;
1309
1310 for (i = 0; i < ARRAY_SIZE(ht20); i++) {
1311 if (rate == ht20[i]) {
1312 if (i == ARRAY_SIZE(ht20) - 1)
1313 /* last rate uses sgi */
1314 *sgi = true;
1315 else
1316 *sgi = false;
1317
1318 *mcs = i;
1319 return true;
1320 }
1321 }
1322 return false;
1323}
1324
1325static bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
1326{
1327 static const s32 ht40[] = { 13500, 27000, 40500, 54000,
1328 81000, 108000, 121500, 135000,
1329 150000
1330 };
1331 u8 i;
1332
1333 for (i = 0; i < ARRAY_SIZE(ht40); i++) {
1334 if (rate == ht40[i]) {
1335 if (i == ARRAY_SIZE(ht40) - 1)
1336 /* last rate uses sgi */
1337 *sgi = true;
1338 else
1339 *sgi = false;
1340
1341 *mcs = i;
1342 return true;
1343 }
1344 }
1345
1346 return false;
1347}
1348
1349static int ath6kl_get_station(struct wiphy *wiphy, struct net_device *dev,
1350 u8 *mac, struct station_info *sinfo)
1351{
1352 struct ath6kl *ar = ath6kl_priv(dev);
1353 long left;
1354 bool sgi;
1355 s32 rate;
1356 int ret;
1357 u8 mcs;
1358
1359 if (memcmp(mac, ar->bssid, ETH_ALEN) != 0)
1360 return -ENOENT;
1361
1362 if (down_interruptible(&ar->sem))
1363 return -EBUSY;
1364
1365 set_bit(STATS_UPDATE_PEND, &ar->flag);
1366
1367 ret = ath6kl_wmi_get_stats_cmd(ar->wmi);
1368
1369 if (ret != 0) {
1370 up(&ar->sem);
1371 return -EIO;
1372 }
1373
1374 left = wait_event_interruptible_timeout(ar->event_wq,
1375 !test_bit(STATS_UPDATE_PEND,
1376 &ar->flag),
1377 WMI_TIMEOUT);
1378
1379 up(&ar->sem);
1380
1381 if (left == 0)
1382 return -ETIMEDOUT;
1383 else if (left < 0)
1384 return left;
1385
1386 if (ar->target_stats.rx_byte) {
1387 sinfo->rx_bytes = ar->target_stats.rx_byte;
1388 sinfo->filled |= STATION_INFO_RX_BYTES;
1389 sinfo->rx_packets = ar->target_stats.rx_pkt;
1390 sinfo->filled |= STATION_INFO_RX_PACKETS;
1391 }
1392
1393 if (ar->target_stats.tx_byte) {
1394 sinfo->tx_bytes = ar->target_stats.tx_byte;
1395 sinfo->filled |= STATION_INFO_TX_BYTES;
1396 sinfo->tx_packets = ar->target_stats.tx_pkt;
1397 sinfo->filled |= STATION_INFO_TX_PACKETS;
1398 }
1399
1400 sinfo->signal = ar->target_stats.cs_rssi;
1401 sinfo->filled |= STATION_INFO_SIGNAL;
1402
1403 rate = ar->target_stats.tx_ucast_rate;
1404
1405 if (is_rate_legacy(rate)) {
1406 sinfo->txrate.legacy = rate / 100;
1407 } else if (is_rate_ht20(rate, &mcs, &sgi)) {
1408 if (sgi) {
1409 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1410 sinfo->txrate.mcs = mcs - 1;
1411 } else {
1412 sinfo->txrate.mcs = mcs;
1413 }
1414
1415 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1416 } else if (is_rate_ht40(rate, &mcs, &sgi)) {
1417 if (sgi) {
1418 sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
1419 sinfo->txrate.mcs = mcs - 1;
1420 } else {
1421 sinfo->txrate.mcs = mcs;
1422 }
1423
1424 sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
1425 sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
1426 } else {
1427 ath6kl_warn("invalid rate: %d\n", rate);
1428 return 0;
1429 }
1430
1431 sinfo->filled |= STATION_INFO_TX_BITRATE;
1432
1433 return 0;
1434}
1435
1436static int ath6kl_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1437 struct cfg80211_pmksa *pmksa)
1438{
1439 struct ath6kl *ar = ath6kl_priv(netdev);
1440 return ath6kl_wmi_setpmkid_cmd(ar->wmi, pmksa->bssid,
1441 pmksa->pmkid, true);
1442}
1443
1444static int ath6kl_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
1445 struct cfg80211_pmksa *pmksa)
1446{
1447 struct ath6kl *ar = ath6kl_priv(netdev);
1448 return ath6kl_wmi_setpmkid_cmd(ar->wmi, pmksa->bssid,
1449 pmksa->pmkid, false);
1450}
1451
1452static int ath6kl_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
1453{
1454 struct ath6kl *ar = ath6kl_priv(netdev);
1455 if (test_bit(CONNECTED, &ar->flag))
1456 return ath6kl_wmi_setpmkid_cmd(ar->wmi, ar->bssid, NULL, false);
1457 return 0;
1458}
1459
1460static struct cfg80211_ops ath6kl_cfg80211_ops = {
1461 .change_virtual_intf = ath6kl_cfg80211_change_iface,
1462 .scan = ath6kl_cfg80211_scan,
1463 .connect = ath6kl_cfg80211_connect,
1464 .disconnect = ath6kl_cfg80211_disconnect,
1465 .add_key = ath6kl_cfg80211_add_key,
1466 .get_key = ath6kl_cfg80211_get_key,
1467 .del_key = ath6kl_cfg80211_del_key,
1468 .set_default_key = ath6kl_cfg80211_set_default_key,
1469 .set_wiphy_params = ath6kl_cfg80211_set_wiphy_params,
1470 .set_tx_power = ath6kl_cfg80211_set_txpower,
1471 .get_tx_power = ath6kl_cfg80211_get_txpower,
1472 .set_power_mgmt = ath6kl_cfg80211_set_power_mgmt,
1473 .join_ibss = ath6kl_cfg80211_join_ibss,
1474 .leave_ibss = ath6kl_cfg80211_leave_ibss,
1475 .get_station = ath6kl_get_station,
1476 .set_pmksa = ath6kl_set_pmksa,
1477 .del_pmksa = ath6kl_del_pmksa,
1478 .flush_pmksa = ath6kl_flush_pmksa,
1479};
1480
1481struct wireless_dev *ath6kl_cfg80211_init(struct device *dev)
1482{
1483 int ret = 0;
1484 struct wireless_dev *wdev;
1485
1486 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
1487 if (!wdev) {
1488 ath6kl_err("couldn't allocate wireless device\n");
1489 return NULL;
1490 }
1491
1492 /* create a new wiphy for use with cfg80211 */
1493 wdev->wiphy = wiphy_new(&ath6kl_cfg80211_ops, sizeof(struct ath6kl));
1494 if (!wdev->wiphy) {
1495 ath6kl_err("couldn't allocate wiphy device\n");
1496 kfree(wdev);
1497 return NULL;
1498 }
1499
1500 /* set device pointer for wiphy */
1501 set_wiphy_dev(wdev->wiphy, dev);
1502
1503 wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
1504 BIT(NL80211_IFTYPE_ADHOC);
1505 /* max num of ssids that can be probed during scanning */
1506 wdev->wiphy->max_scan_ssids = MAX_PROBED_SSID_INDEX;
1507 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &ath6kl_band_2ghz;
1508 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &ath6kl_band_5ghz;
1509 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
1510
1511 wdev->wiphy->cipher_suites = cipher_suites;
1512 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
1513
1514 ret = wiphy_register(wdev->wiphy);
1515 if (ret < 0) {
1516 ath6kl_err("couldn't register wiphy device\n");
1517 wiphy_free(wdev->wiphy);
1518 kfree(wdev);
1519 return NULL;
1520 }
1521
1522 return wdev;
1523}
1524
1525void ath6kl_cfg80211_deinit(struct ath6kl *ar)
1526{
1527 struct wireless_dev *wdev = ar->wdev;
1528
1529 if (ar->scan_req) {
1530 cfg80211_scan_done(ar->scan_req, true);
1531 ar->scan_req = NULL;
1532 }
1533
1534 if (!wdev)
1535 return;
1536
1537 wiphy_unregister(wdev->wiphy);
1538 wiphy_free(wdev->wiphy);
1539 kfree(wdev);
1540}
Linux kernel - Deliverables
This page took 0.084369 seconds and 5 git commands to generate.