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