Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / drivers / net / wireless / iwmc3200wifi / cfg80211.c
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                 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
682                                               CFG_TX_PWR_LIMIT_USR, dbm * 2);
683                 if (ret < 0)
684                         return ret;
685
686                 return iwm_tx_power_trigger(iwm);
687         default:
688                 return -EOPNOTSUPP;
689         }
690
691         return 0;
692 }
693
694 static int iwm_cfg80211_get_txpower(struct wiphy *wiphy, int *dbm)
695 {
696         struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
697
698         *dbm = iwm->txpower >> 1;
699
700         return 0;
701 }
702
703 static int iwm_cfg80211_set_power_mgmt(struct wiphy *wiphy,
704                                        struct net_device *dev,
705                                        bool enabled, int timeout)
706 {
707         struct iwm_priv *iwm = wiphy_to_iwm(wiphy);
708         u32 power_index;
709
710         if (enabled)
711                 power_index = IWM_POWER_INDEX_DEFAULT;
712         else
713                 power_index = IWM_POWER_INDEX_MIN;
714
715         if (power_index == iwm->conf.power_index)
716                 return 0;
717
718         iwm->conf.power_index = power_index;
719
720         return iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
721                                        CFG_POWER_INDEX, iwm->conf.power_index);
722 }
723
724 static struct cfg80211_ops iwm_cfg80211_ops = {
725         .change_virtual_intf = iwm_cfg80211_change_iface,
726         .add_key = iwm_cfg80211_add_key,
727         .get_key = iwm_cfg80211_get_key,
728         .del_key = iwm_cfg80211_del_key,
729         .set_default_key = iwm_cfg80211_set_default_key,
730         .get_station = iwm_cfg80211_get_station,
731         .scan = iwm_cfg80211_scan,
732         .set_wiphy_params = iwm_cfg80211_set_wiphy_params,
733         .connect = iwm_cfg80211_connect,
734         .disconnect = iwm_cfg80211_disconnect,
735         .join_ibss = iwm_cfg80211_join_ibss,
736         .leave_ibss = iwm_cfg80211_leave_ibss,
737         .set_tx_power = iwm_cfg80211_set_txpower,
738         .get_tx_power = iwm_cfg80211_get_txpower,
739         .set_power_mgmt = iwm_cfg80211_set_power_mgmt,
740 };
741
742 static const u32 cipher_suites[] = {
743         WLAN_CIPHER_SUITE_WEP40,
744         WLAN_CIPHER_SUITE_WEP104,
745         WLAN_CIPHER_SUITE_TKIP,
746         WLAN_CIPHER_SUITE_CCMP,
747 };
748
749 struct wireless_dev *iwm_wdev_alloc(int sizeof_bus, struct device *dev)
750 {
751         int ret = 0;
752         struct wireless_dev *wdev;
753
754         /*
755          * We're trying to have the following memory
756          * layout:
757          *
758          * +-------------------------+
759          * | struct wiphy            |
760          * +-------------------------+
761          * | struct iwm_priv         |
762          * +-------------------------+
763          * | bus private data        |
764          * | (e.g. iwm_priv_sdio)    |
765          * +-------------------------+
766          *
767          */
768
769         wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
770         if (!wdev) {
771                 dev_err(dev, "Couldn't allocate wireless device\n");
772                 return ERR_PTR(-ENOMEM);
773         }
774
775         wdev->wiphy = wiphy_new(&iwm_cfg80211_ops,
776                                 sizeof(struct iwm_priv) + sizeof_bus);
777         if (!wdev->wiphy) {
778                 dev_err(dev, "Couldn't allocate wiphy device\n");
779                 ret = -ENOMEM;
780                 goto out_err_new;
781         }
782
783         set_wiphy_dev(wdev->wiphy, dev);
784         wdev->wiphy->max_scan_ssids = UMAC_WIFI_IF_PROBE_OPTION_MAX;
785         wdev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
786                                        BIT(NL80211_IFTYPE_ADHOC);
787         wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &iwm_band_2ghz;
788         wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &iwm_band_5ghz;
789         wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
790
791         wdev->wiphy->cipher_suites = cipher_suites;
792         wdev->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
793
794         ret = wiphy_register(wdev->wiphy);
795         if (ret < 0) {
796                 dev_err(dev, "Couldn't register wiphy device\n");
797                 goto out_err_register;
798         }
799
800         return wdev;
801
802  out_err_register:
803         wiphy_free(wdev->wiphy);
804
805  out_err_new:
806         kfree(wdev);
807
808         return ERR_PTR(ret);
809 }
810
811 void iwm_wdev_free(struct iwm_priv *iwm)
812 {
813         struct wireless_dev *wdev = iwm_to_wdev(iwm);
814
815         if (!wdev)
816                 return;
817
818         wiphy_unregister(wdev->wiphy);
819         wiphy_free(wdev->wiphy);
820         kfree(wdev);
821 }