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