?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwmc3200wifi: Implement cfg80211 PMKSA API
[linux/fpc-iii.git] / drivers / net / wireless / iwmc3200wifi / cfg80211.c
blob7c4f44a9c3e6b2a8429fe168a08ce53588feb9c8
1 /*
2 * Intel Wireless Multicomm 3200 WiFi driver
3 *
4 * Copyright (C) 2009 Intel Corporation <ilw@linux.intel.com>
5 * Samuel Ortiz <samuel.ortiz@intel.com>
6 * Zhu Yi <yi.zhu@intel.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA.
21 *
22 */
23
24 #include <linux/kernel.h>
25 #include <linux/netdevice.h>
26 #include <linux/sched.h>
27 #include <linux/etherdevice.h>
28 #include <linux/wireless.h>
29 #include <linux/ieee80211.h>
30 #include <net/cfg80211.h>
31
32 #include "iwm.h"
33 #include "commands.h"
34 #include "cfg80211.h"
35 #include "debug.h"
36
37 #define RATETAB_ENT(_rate, _rateid, _flags) \
38 { \
39 .bitrate = (_rate), \
40 .hw_value = (_rateid), \
41 .flags = (_flags), \
42 }
43
44 #define CHAN2G(_channel, _freq, _flags) { \
45 .band = IEEE80211_BAND_2GHZ, \
46 .center_freq = (_freq), \
47 .hw_value = (_channel), \
48 .flags = (_flags), \
49 .max_antenna_gain = 0, \
50 .max_power = 30, \
51 }
52
53 #define CHAN5G(_channel, _flags) { \
54 .band = IEEE80211_BAND_5GHZ, \
55 .center_freq = 5000 + (5 * (_channel)), \
56 .hw_value = (_channel), \
57 .flags = (_flags), \
58 .max_antenna_gain = 0, \
59 .max_power = 30, \
60 }
61
62 static struct ieee80211_rate iwm_rates[] = {
63 RATETAB_ENT(10, 0x1, 0),
64 RATETAB_ENT(20, 0x2, 0),
65 RATETAB_ENT(55, 0x4, 0),
66 RATETAB_ENT(110, 0x8, 0),
67 RATETAB_ENT(60, 0x10, 0),
68 RATETAB_ENT(90, 0x20, 0),
69 RATETAB_ENT(120, 0x40, 0),
70 RATETAB_ENT(180, 0x80, 0),
71 RATETAB_ENT(240, 0x100, 0),
72 RATETAB_ENT(360, 0x200, 0),
73 RATETAB_ENT(480, 0x400, 0),
74 RATETAB_ENT(540, 0x800, 0),
75 };
76
77 #define iwm_a_rates (iwm_rates + 4)
78 #define iwm_a_rates_size 8
79 #define iwm_g_rates (iwm_rates + 0)
80 #define iwm_g_rates_size 12
81
82 static struct ieee80211_channel iwm_2ghz_channels[] = {
83 CHAN2G(1, 2412, 0),
84 CHAN2G(2, 2417, 0),
85 CHAN2G(3, 2422, 0),
86 CHAN2G(4, 2427, 0),
87 CHAN2G(5, 2432, 0),
88 CHAN2G(6, 2437, 0),
89 CHAN2G(7, 2442, 0),
90 CHAN2G(8, 2447, 0),
91 CHAN2G(9, 2452, 0),
92 CHAN2G(10, 2457, 0),
93 CHAN2G(11, 2462, 0),
94 CHAN2G(12, 2467, 0),
95 CHAN2G(13, 2472, 0),
96 CHAN2G(14, 2484, 0),
97 };
98
99 static struct ieee80211_channel iwm_5ghz_a_channels[] = {
100 CHAN5G(34, 0), CHAN5G(36, 0),
101 CHAN5G(38, 0), CHAN5G(40, 0),
102 CHAN5G(42, 0), CHAN5G(44, 0),
103 CHAN5G(46, 0), CHAN5G(48, 0),
104 CHAN5G(52, 0), CHAN5G(56, 0),
105 CHAN5G(60, 0), CHAN5G(64, 0),
106 CHAN5G(100, 0), CHAN5G(104, 0),
107 CHAN5G(108, 0), CHAN5G(112, 0),
108 CHAN5G(116, 0), CHAN5G(120, 0),
109 CHAN5G(124, 0), CHAN5G(128, 0),
110 CHAN5G(132, 0), CHAN5G(136, 0),
111 CHAN5G(140, 0), CHAN5G(149, 0),
112 CHAN5G(153, 0), CHAN5G(157, 0),
113 CHAN5G(161, 0), CHAN5G(165, 0),
114 CHAN5G(184, 0), CHAN5G(188, 0),
115 CHAN5G(192, 0), CHAN5G(196, 0),
116 CHAN5G(200, 0), CHAN5G(204, 0),
117 CHAN5G(208, 0), CHAN5G(212, 0),
118 CHAN5G(216, 0),
119 };
120
121 static struct ieee80211_supported_band iwm_band_2ghz = {
122 .channels = iwm_2ghz_channels,
123 .n_channels = ARRAY_SIZE(iwm_2ghz_channels),
124 .bitrates = iwm_g_rates,
125 .n_bitrates = iwm_g_rates_size,
126 };
127
128 static struct ieee80211_supported_band iwm_band_5ghz = {
129 .channels = iwm_5ghz_a_channels,
130 .n_channels = ARRAY_SIZE(iwm_5ghz_a_channels),
131 .bitrates = iwm_a_rates,
132 .n_bitrates = iwm_a_rates_size,
133 };
134
135 static int iwm_key_init(struct iwm_key *key, u8 key_index,
136 const u8 *mac_addr, struct key_params *params)
137 {
138 key->hdr.key_idx = key_index;
139 if (!mac_addr || is_broadcast_ether_addr(mac_addr)) {
140 key->hdr.multicast = 1;
141 memset(key->hdr.mac, 0xff, ETH_ALEN);
142 } else {
143 key->hdr.multicast = 0;
144 memcpy(key->hdr.mac, mac_addr, ETH_ALEN);
145 }
146
147 if (params) {
148 if (params->key_len > WLAN_MAX_KEY_LEN ||
149 params->seq_len > IW_ENCODE_SEQ_MAX_SIZE)
150 return -EINVAL;
151
152 key->cipher = params->cipher;
153 key->key_len = params->key_len;
154 key->seq_len = params->seq_len;
155 memcpy(key->key, params->key, key->key_len);
156 memcpy(key->seq, params->seq, key->seq_len);
157 }
158
159 return 0;
160 }
161
162 static int iwm_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
163 u8 key_index, const u8 *mac_addr,
164 struct key_params *params)
165 {
166 struct iwm_priv *iwm = ndev_to_iwm(ndev);
167 struct iwm_key *key = &iwm->keys[key_index];
168 int ret;
169
170 IWM_DBG_WEXT(iwm, DBG, "Adding key for %pM\n", mac_addr);
171
172 memset(key, 0, sizeof(struct iwm_key));
173 ret = iwm_key_init(key, key_index, mac_addr, params);
174 if (ret < 0) {
175 IWM_ERR(iwm, "Invalid key_params\n");
176 return ret;
177 }
178
179 return iwm_set_key(iwm, 0, key);
180 }
181
182 static int iwm_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
183 u8 key_index, const u8 *mac_addr, void *cookie,
184 void (*callback)(void *cookie,
185 struct key_params*))
186 {
187 struct iwm_priv *iwm = ndev_to_iwm(ndev);
188 struct iwm_key *key = &iwm->keys[key_index];
189 struct key_params params;
190
191 IWM_DBG_WEXT(iwm, DBG, "Getting key %d\n", key_index);
192
193 memset(&params, 0, sizeof(params));
194
195 params.cipher = key->cipher;
196 params.key_len = key->key_len;
197 params.seq_len = key->seq_len;
198 params.seq = key->seq;
199 params.key = key->key;
200
201 callback(cookie, &params);
202
203 return key->key_len ? 0 : -ENOENT;
204 }
205
206
207 static int iwm_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
208 u8 key_index, const u8 *mac_addr)
209 {
210 struct iwm_priv *iwm = ndev_to_iwm(ndev);
211 struct iwm_key *key = &iwm->keys[key_index];
212
213 if (!iwm->keys[key_index].key_len) {
214 IWM_DBG_WEXT(iwm, DBG, "Key %d not used\n", key_index);
215 return 0;
216 }
217
218 if (key_index == iwm->default_key)
219 iwm->default_key = -1;
220
221 return iwm_set_key(iwm, 1, key);
222 }
223
224 static int iwm_cfg80211_set_default_key(struct wiphy *wiphy,
225 struct net_device *ndev,
226 u8 key_index)
227 {
228 struct iwm_priv *iwm = ndev_to_iwm(ndev);
229
230 IWM_DBG_WEXT(iwm, DBG, "Default key index is: %d\n", key_index);
231
232 if (!iwm->keys[key_index].key_len) {
233 IWM_ERR(iwm, "Key %d not used\n", key_index);
234 return -EINVAL;
235 }
236
237 iwm->default_key = key_index;
238
239 return iwm_set_tx_key(iwm, key_index);
240 }
241
242 static int iwm_cfg80211_get_station(struct wiphy *wiphy,
243 struct net_device *ndev,
244 u8 *mac, struct station_info *sinfo)
245 {
246 struct iwm_priv *iwm = ndev_to_iwm(ndev);
247
248 if (memcmp(mac, iwm->bssid, ETH_ALEN))
249 return -ENOENT;
250
251 sinfo->filled |= STATION_INFO_TX_BITRATE;
252 sinfo->txrate.legacy = iwm->rate * 10;
253
254 if (test_bit(IWM_STATUS_ASSOCIATED, &iwm->status)) {
255 sinfo->filled |= STATION_INFO_SIGNAL;
256 sinfo->signal = iwm->wstats.qual.level;
257 }
258
259 return 0;
260 }
261
262
263 int iwm_cfg80211_inform_bss(struct iwm_priv *iwm)
264 {
265 struct wiphy *wiphy = iwm_to_wiphy(iwm);
266 struct iwm_bss_info *bss, *next;
267 struct iwm_umac_notif_bss_info *umac_bss;
268 struct ieee80211_mgmt *mgmt;
269 struct ieee80211_channel *channel;
270 struct ieee80211_supported_band *band;
271 s32 signal;
272 int freq;
273
274 list_for_each_entry_safe(bss, next, &iwm->bss_list, node) {
275 umac_bss = bss->bss;
276 mgmt = (struct ieee80211_mgmt *)(umac_bss->frame_buf);
277
278 if (umac_bss->band == UMAC_BAND_2GHZ)
279 band = wiphy->bands[IEEE80211_BAND_2GHZ];
280 else if (umac_bss->band == UMAC_BAND_5GHZ)
281 band = wiphy->bands[IEEE80211_BAND_5GHZ];
282 else {
283 IWM_ERR(iwm, "Invalid band: %d\n", umac_bss->band);
284 return -EINVAL;
285 }
286
287 freq = ieee80211_channel_to_frequency(umac_bss->channel);
288 channel = ieee80211_get_channel(wiphy, freq);
289 signal = umac_bss->rssi * 100;
290
291 if (!cfg80211_inform_bss_frame(wiphy, channel, mgmt,
292 le16_to_cpu(umac_bss->frame_len),
293 signal, GFP_KERNEL))
294 return -EINVAL;
295 }
296
297 return 0;
298 }
299
300 static int iwm_cfg80211_change_iface(struct wiphy *wiphy,
301 struct net_device *ndev,
302 enum nl80211_iftype type, u32 *flags,
303 struct vif_params *params)
304 {
305 struct wireless_dev *wdev;
306 struct iwm_priv *iwm;
307 u32 old_mode;
308
309 wdev = ndev->ieee80211_ptr;
310 iwm = ndev_to_iwm(ndev);
311 old_mode = iwm->conf.mode;
312
313 switch (type) {
314 case NL80211_IFTYPE_STATION:
315 iwm->conf.mode = UMAC_MODE_BSS;
316 break;
317 case NL80211_IFTYPE_ADHOC:
318 iwm->conf.mode = UMAC_MODE_IBSS;
319 break;
320 default:
321 return -EOPNOTSUPP;
322 }
323
324 wdev->iftype = type;
325
326 if ((old_mode == iwm->conf.mode) || !iwm->umac_profile)
327 return 0;
328
329 iwm->umac_profile->mode = cpu_to_le32(iwm->conf.mode);
330
331 if (iwm->umac_profile_active)
332 iwm_invalidate_mlme_profile(iwm);
333
334 return 0;
335 }
336
337 static int iwm_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
338 struct cfg80211_scan_request *request)
339 {
340 struct iwm_priv *iwm = ndev_to_iwm(ndev);
341 int ret;
342
343 if (!test_bit(IWM_STATUS_READY, &iwm->status)) {
344 IWM_ERR(iwm, "Scan while device is not ready\n");
345 return -EIO;
346 }
347
348 if (test_bit(IWM_STATUS_SCANNING, &iwm->status)) {
349 IWM_ERR(iwm, "Scanning already\n");
350 return -EAGAIN;
351 }
352
353 if (test_bit(IWM_STATUS_SCAN_ABORTING, &iwm->status)) {
354 IWM_ERR(iwm, "Scanning being aborted\n");
355 return -EAGAIN;
356 }
357
358 set_bit(IWM_STATUS_SCANNING, &iwm->status);
359
360 ret = iwm_scan_ssids(iwm, request->ssids, request->n_ssids);
361 if (ret) {
362 clear_bit(IWM_STATUS_SCANNING, &iwm->status);
363 return ret;
364 }
365
366 iwm->scan_request = request;
367 return 0;
368 }
369
370 static int iwm_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
371 {
372 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
373
374 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
375 (iwm->conf.rts_threshold != wiphy->rts_threshold)) {
376 int ret;
377
378 iwm->conf.rts_threshold = wiphy->rts_threshold;
379
380 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
381 CFG_RTS_THRESHOLD,
382 iwm->conf.rts_threshold);
383 if (ret < 0)
384 return ret;
385 }
386
387 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
388 (iwm->conf.frag_threshold != wiphy->frag_threshold)) {
389 int ret;
390
391 iwm->conf.frag_threshold = wiphy->frag_threshold;
392
393 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_FA_CFG_FIX,
394 CFG_FRAG_THRESHOLD,
395 iwm->conf.frag_threshold);
396 if (ret < 0)
397 return ret;
398 }
399
400 return 0;
401 }
402
403 static int iwm_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
404 struct cfg80211_ibss_params *params)
405 {
406 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
407 struct ieee80211_channel *chan = params->channel;
408
409 if (!test_bit(IWM_STATUS_READY, &iwm->status))
410 return -EIO;
411
412 /* UMAC doesn't support creating or joining an IBSS network
413 * with specified bssid. */
414 if (params->bssid)
415 return -EOPNOTSUPP;
416
417 iwm->channel = ieee80211_frequency_to_channel(chan->center_freq);
418 iwm->umac_profile->ibss.band = chan->band;
419 iwm->umac_profile->ibss.channel = iwm->channel;
420 iwm->umac_profile->ssid.ssid_len = params->ssid_len;
421 memcpy(iwm->umac_profile->ssid.ssid, params->ssid, params->ssid_len);
422
423 return iwm_send_mlme_profile(iwm);
424 }
425
426 static int iwm_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
427 {
428 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
429
430 if (iwm->umac_profile_active)
431 return iwm_invalidate_mlme_profile(iwm);
432
433 return 0;
434 }
435
436 static int iwm_set_auth_type(struct iwm_priv *iwm,
437 enum nl80211_auth_type sme_auth_type)
438 {
439 u8 *auth_type = &iwm->umac_profile->sec.auth_type;
440
441 switch (sme_auth_type) {
442 case NL80211_AUTHTYPE_AUTOMATIC:
443 case NL80211_AUTHTYPE_OPEN_SYSTEM:
444 IWM_DBG_WEXT(iwm, DBG, "OPEN auth\n");
445 *auth_type = UMAC_AUTH_TYPE_OPEN;
446 break;
447 case NL80211_AUTHTYPE_SHARED_KEY:
448 if (iwm->umac_profile->sec.flags &
449 (UMAC_SEC_FLG_WPA_ON_MSK | UMAC_SEC_FLG_RSNA_ON_MSK)) {
450 IWM_DBG_WEXT(iwm, DBG, "WPA auth alg\n");
451 *auth_type = UMAC_AUTH_TYPE_RSNA_PSK;
452 } else {
453 IWM_DBG_WEXT(iwm, DBG, "WEP shared key auth alg\n");
454 *auth_type = UMAC_AUTH_TYPE_LEGACY_PSK;
455 }
456
457 break;
458 default:
459 IWM_ERR(iwm, "Unsupported auth alg: 0x%x\n", sme_auth_type);
460 return -ENOTSUPP;
461 }
462
463 return 0;
464 }
465
466 static int iwm_set_wpa_version(struct iwm_priv *iwm, u32 wpa_version)
467 {
468 IWM_DBG_WEXT(iwm, DBG, "wpa_version: %d\n", wpa_version);
469
470 if (!wpa_version) {
471 iwm->umac_profile->sec.flags = UMAC_SEC_FLG_LEGACY_PROFILE;
472 return 0;
473 }
474
475 if (wpa_version & NL80211_WPA_VERSION_1)
476 iwm->umac_profile->sec.flags = UMAC_SEC_FLG_WPA_ON_MSK;
477
478 if (wpa_version & NL80211_WPA_VERSION_2)
479 iwm->umac_profile->sec.flags = UMAC_SEC_FLG_RSNA_ON_MSK;
480
481 return 0;
482 }
483
484 static int iwm_set_cipher(struct iwm_priv *iwm, u32 cipher, bool ucast)
485 {
486 u8 *profile_cipher = ucast ? &iwm->umac_profile->sec.ucast_cipher :
487 &iwm->umac_profile->sec.mcast_cipher;
488
489 if (!cipher) {
490 *profile_cipher = UMAC_CIPHER_TYPE_NONE;
491 return 0;
492 }
493
494 IWM_DBG_WEXT(iwm, DBG, "%ccast cipher is 0x%x\n", ucast ? 'u' : 'm',
495 cipher);
496
497 switch (cipher) {
498 case IW_AUTH_CIPHER_NONE:
499 *profile_cipher = UMAC_CIPHER_TYPE_NONE;
500 break;
501 case WLAN_CIPHER_SUITE_WEP40:
502 *profile_cipher = UMAC_CIPHER_TYPE_WEP_40;
503 break;
504 case WLAN_CIPHER_SUITE_WEP104:
505 *profile_cipher = UMAC_CIPHER_TYPE_WEP_104;
506 break;
507 case WLAN_CIPHER_SUITE_TKIP:
508 *profile_cipher = UMAC_CIPHER_TYPE_TKIP;
509 break;
510 case WLAN_CIPHER_SUITE_CCMP:
511 *profile_cipher = UMAC_CIPHER_TYPE_CCMP;
512 break;
513 default:
514 IWM_ERR(iwm, "Unsupported cipher: 0x%x\n", cipher);
515 return -ENOTSUPP;
516 }
517
518 return 0;
519 }
520
521 static int iwm_set_key_mgt(struct iwm_priv *iwm, u32 key_mgt)
522 {
523 u8 *auth_type = &iwm->umac_profile->sec.auth_type;
524
525 IWM_DBG_WEXT(iwm, DBG, "key_mgt: 0x%x\n", key_mgt);
526
527 if (key_mgt == WLAN_AKM_SUITE_8021X)
528 *auth_type = UMAC_AUTH_TYPE_8021X;
529 else if (key_mgt == WLAN_AKM_SUITE_PSK) {
530 if (iwm->umac_profile->sec.flags &
531 (UMAC_SEC_FLG_WPA_ON_MSK | UMAC_SEC_FLG_RSNA_ON_MSK))
532 *auth_type = UMAC_AUTH_TYPE_RSNA_PSK;
533 else
534 *auth_type = UMAC_AUTH_TYPE_LEGACY_PSK;
535 } else {
536 IWM_ERR(iwm, "Invalid key mgt: 0x%x\n", key_mgt);
537 return -EINVAL;
538 }
539
540 return 0;
541 }
542
543
544 static int iwm_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
545 struct cfg80211_connect_params *sme)
546 {
547 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
548 struct ieee80211_channel *chan = sme->channel;
549 struct key_params key_param;
550 int ret;
551
552 if (!test_bit(IWM_STATUS_READY, &iwm->status))
553 return -EIO;
554
555 if (!sme->ssid)
556 return -EINVAL;
557
558 if (iwm->umac_profile_active) {
559 ret = iwm_invalidate_mlme_profile(iwm);
560 if (ret) {
561 IWM_ERR(iwm, "Couldn't invalidate profile\n");
562 return ret;
563 }
564 }
565
566 if (chan)
567 iwm->channel =
568 ieee80211_frequency_to_channel(chan->center_freq);
569
570 iwm->umac_profile->ssid.ssid_len = sme->ssid_len;
571 memcpy(iwm->umac_profile->ssid.ssid, sme->ssid, sme->ssid_len);
572
573 if (sme->bssid) {
574 IWM_DBG_WEXT(iwm, DBG, "BSSID: %pM\n", sme->bssid);
575 memcpy(&iwm->umac_profile->bssid[0], sme->bssid, ETH_ALEN);
576 iwm->umac_profile->bss_num = 1;
577 } else {
578 memset(&iwm->umac_profile->bssid[0], 0, ETH_ALEN);
579 iwm->umac_profile->bss_num = 0;
580 }
581
582 ret = iwm_set_wpa_version(iwm, sme->crypto.wpa_versions);
583 if (ret < 0)
584 return ret;
585
586 ret = iwm_set_auth_type(iwm, sme->auth_type);
587 if (ret < 0)
588 return ret;
589
590 if (sme->crypto.n_ciphers_pairwise) {
591 ret = iwm_set_cipher(iwm, sme->crypto.ciphers_pairwise[0],
592 true);
593 if (ret < 0)
594 return ret;
595 }
596
597 ret = iwm_set_cipher(iwm, sme->crypto.cipher_group, false);
598 if (ret < 0)
599 return ret;
600
601 if (sme->crypto.n_akm_suites) {
602 ret = iwm_set_key_mgt(iwm, sme->crypto.akm_suites[0]);
603 if (ret < 0)
604 return ret;
605 }
606
607 /*
608 * We save the WEP key in case we want to do shared authentication.
609 * We have to do it so because UMAC will assert whenever it gets a
610 * key before a profile.
611 */
612 if (sme->key) {
613 key_param.key = kmemdup(sme->key, sme->key_len, GFP_KERNEL);
614 if (key_param.key == NULL)
615 return -ENOMEM;
616 key_param.key_len = sme->key_len;
617 key_param.seq_len = 0;
618 key_param.cipher = sme->crypto.ciphers_pairwise[0];
619
620 ret = iwm_key_init(&iwm->keys[sme->key_idx], sme->key_idx,
621 NULL, &key_param);
622 kfree(key_param.key);
623 if (ret < 0) {
624 IWM_ERR(iwm, "Invalid key_params\n");
625 return ret;
626 }
627
628 iwm->default_key = sme->key_idx;
629 }
630
631 /* WPA and open AUTH type from wpa_s means WPS (a.k.a. WSC) */
632 if ((iwm->umac_profile->sec.flags &
633 (UMAC_SEC_FLG_WPA_ON_MSK | UMAC_SEC_FLG_RSNA_ON_MSK)) &&
634 iwm->umac_profile->sec.auth_type == UMAC_AUTH_TYPE_OPEN) {
635 iwm->umac_profile->sec.flags = UMAC_SEC_FLG_WSC_ON_MSK;
636 }
637
638 ret = iwm_send_mlme_profile(iwm);
639
640 if (iwm->umac_profile->sec.auth_type != UMAC_AUTH_TYPE_LEGACY_PSK ||
641 sme->key == NULL)
642 return ret;
643
644 /*
645 * We want to do shared auth.
646 * We need to actually set the key we previously cached,
647 * and then tell the UMAC it's the default one.
648 * That will trigger the auth+assoc UMAC machinery, and again,
649 * this must be done after setting the profile.
650 */
651 ret = iwm_set_key(iwm, 0, &iwm->keys[sme->key_idx]);
652 if (ret < 0)
653 return ret;
654
655 return iwm_set_tx_key(iwm, iwm->default_key);
656 }
657
658 static int iwm_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
659 u16 reason_code)
660 {
661 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
662
663 IWM_DBG_WEXT(iwm, DBG, "Active: %d\n", iwm->umac_profile_active);
664
665 if (iwm->umac_profile_active)
666 iwm_invalidate_mlme_profile(iwm);
667
668 return 0;
669 }
670
671 static int iwm_cfg80211_set_txpower(struct wiphy *wiphy,
672 enum tx_power_setting type, int dbm)
673 {
674 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
675 int ret;
676
677 switch (type) {
678 case TX_POWER_AUTOMATIC:
679 return 0;
680 case TX_POWER_FIXED:
681 if (!test_bit(IWM_STATUS_READY, &iwm->status))
682 return 0;
683
684 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
685 CFG_TX_PWR_LIMIT_USR, dbm * 2);
686 if (ret < 0)
687 return ret;
688
689 return iwm_tx_power_trigger(iwm);
690 default:
691 IWM_ERR(iwm, "Unsupported power type: %d\n", type);
692 return -EOPNOTSUPP;
693 }
694
695 return 0;
696 }
697
698 static int iwm_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm)
699 {
700 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
701
702 *dbm = iwm->txpower >> 1;
703
704 return 0;
705 }
706
707 static int iwm_cfg80211_set_power_mgmt(struct wiphy *wiphy,
708 struct net_device *dev,
709 bool enabled, int timeout)
710 {
711 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
712 u32 power_index;
713
714 if (enabled)
715 power_index = IWM_POWER_INDEX_DEFAULT;
716 else
717 power_index = IWM_POWER_INDEX_MIN;
718
719 if (power_index == iwm->conf.power_index)
720 return 0;
721
722 iwm->conf.power_index = power_index;
723
724 return iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
725 CFG_POWER_INDEX, iwm->conf.power_index);
726 }
727
728 int iwm_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *netdev,
729 struct cfg80211_pmksa *pmksa)
730 {
731 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
732
733 return iwm_send_pmkid_update(iwm, pmksa, IWM_CMD_PMKID_ADD);
734 }
735
736 int iwm_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *netdev,
737 struct cfg80211_pmksa *pmksa)
738 {
739 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
740
741 return iwm_send_pmkid_update(iwm, pmksa, IWM_CMD_PMKID_DEL);
742 }
743
744 int iwm_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *netdev)
745 {
746 struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
747 struct cfg80211_pmksa pmksa;
748
749 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
750
751 return iwm_send_pmkid_update(iwm, &pmksa, IWM_CMD_PMKID_FLUSH);
752 }
753
754
755 static struct cfg80211_ops iwm_cfg80211_ops = {
756 .change_virtual_intf = iwm_cfg80211_change_iface,
757 .add_key = iwm_cfg80211_add_key,
758 .get_key = iwm_cfg80211_get_key,
759 .del_key = iwm_cfg80211_del_key,
760 .set_default_key = iwm_cfg80211_set_default_key,
761 .get_station = iwm_cfg80211_get_station,
762 .scan = iwm_cfg80211_scan,
763 .set_wiphy_params = iwm_cfg80211_set_wiphy_params,
764 .connect = iwm_cfg80211_connect,
765 .disconnect = iwm_cfg80211_disconnect,
766 .join_ibss = iwm_cfg80211_join_ibss,
767 .leave_ibss = iwm_cfg80211_leave_ibss,
768 .set_tx_power = iwm_cfg80211_set_txpower,
769 .get_tx_power = iwm_cfg80211_get_txpower,
770 .set_power_mgmt = iwm_cfg80211_set_power_mgmt,
771 .set_pmksa = iwm_cfg80211_set_pmksa,
772 .del_pmksa = iwm_cfg80211_del_pmksa,
773 .flush_pmksa = iwm_cfg80211_flush_pmksa,
774 };
775
776 static const u32 cipher_suites[] = {
777 WLAN_CIPHER_SUITE_WEP40,
778 WLAN_CIPHER_SUITE_WEP104,
779 WLAN_CIPHER_SUITE_TKIP,
780 WLAN_CIPHER_SUITE_CCMP,
781 };
782
783 struct wireless_dev *iwm_wdev_alloc(int sizeof_bus, struct device *dev)
784 {
785 int ret = 0;
786 struct wireless_dev *wdev;
787
788 /*
789 * We're trying to have the following memory
790 * layout:
791 *
792 * +-------------------------+
793 * | struct wiphy |
794 * +-------------------------+
795 * | struct iwm_priv |
796 * +-------------------------+
797 * | bus private data |
798 * | (e.g. iwm_priv_sdio) |
799 * +-------------------------+
800 *
801 */
802
803 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
804 if (!wdev) {
805 dev_err(dev, "Couldn't allocate wireless device\n");
806 return ERR_PTR(-ENOMEM);
807 }
808
809 wdev->wiphy = wiphy_new(&iwm_cfg80211_ops,
810 sizeof(struct iwm_priv) + sizeof_bus);
811 if (!wdev->wiphy) {
812 dev_err(dev, "Couldn't allocate wiphy device\n");
813 ret = -ENOMEM;
814 goto out_err_new;
815 }
816
817 set_wiphy_dev(wdev->wiphy, dev);
818 wdev->wiphy->max_scan_ssids = UMAC_WIFI_IF_PROBE_OPTION_MAX;
819 wdev->wiphy->max_num_pmkids = UMAC_MAX_NUM_PMKIDS;
820 wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
821 BIT(NL80211_IFTYPE_ADHOC);
822 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &iwm_band_2ghz;
823 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &iwm_band_5ghz;
824 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
825
826 wdev->wiphy->cipher_suites = cipher_suites;
827 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
828
829 ret = wiphy_register(wdev->wiphy);
830 if (ret < 0) {
831 dev_err(dev, "Couldn't register wiphy device\n");
832 goto out_err_register;
833 }
834
835 return wdev;
836
837 out_err_register:
838 wiphy_free(wdev->wiphy);
839
840 out_err_new:
841 kfree(wdev);
842
843 return ERR_PTR(ret);
844 }
845
846 void iwm_wdev_free(struct iwm_priv *iwm)
847 {
848 struct wireless_dev *wdev = iwm_to_wdev(iwm);
849
850 if (!wdev)
851 return;
852
853 wiphy_unregister(wdev->wiphy);
854 wiphy_free(wdev->wiphy);
855 kfree(wdev);
856 }
Linux with added FPC-III support