net: remove interrupt.h inclusion from netdevice.h
[linux-3.10.git] / drivers / net / wireless / ipw2x00 / libipw_wx.c
1 /******************************************************************************
2
3   Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
4
5   Portions of this file are based on the WEP enablement code provided by the
6   Host AP project hostap-drivers v0.1.3
7   Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
8   <j@w1.fi>
9   Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
10
11   This program is free software; you can redistribute it and/or modify it
12   under the terms of version 2 of the GNU General Public License as
13   published by the Free Software Foundation.
14
15   This program is distributed in the hope that it will be useful, but WITHOUT
16   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18   more details.
19
20   You should have received a copy of the GNU General Public License along with
21   this program; if not, write to the Free Software Foundation, Inc., 59
22   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23
24   The full GNU General Public License is included in this distribution in the
25   file called LICENSE.
26
27   Contact Information:
28   Intel Linux Wireless <ilw@linux.intel.com>
29   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30
31 ******************************************************************************/
32
33 #include <linux/hardirq.h>
34 #include <linux/kmod.h>
35 #include <linux/slab.h>
36 #include <linux/module.h>
37 #include <linux/jiffies.h>
38
39 #include <net/lib80211.h>
40 #include <linux/wireless.h>
41
42 #include "libipw.h"
43
44 static const char *libipw_modes[] = {
45         "?", "a", "b", "ab", "g", "ag", "bg", "abg"
46 };
47
48 static inline unsigned int elapsed_jiffies_msecs(unsigned long start)
49 {
50         unsigned long end = jiffies;
51
52         if (end >= start)
53                 return jiffies_to_msecs(end - start);
54
55         return jiffies_to_msecs(end + (MAX_JIFFY_OFFSET - start) + 1);
56 }
57
58 #define MAX_CUSTOM_LEN 64
59 static char *libipw_translate_scan(struct libipw_device *ieee,
60                                       char *start, char *stop,
61                                       struct libipw_network *network,
62                                       struct iw_request_info *info)
63 {
64         char custom[MAX_CUSTOM_LEN];
65         char *p;
66         struct iw_event iwe;
67         int i, j;
68         char *current_val;      /* For rates */
69         u8 rate;
70
71         /* First entry *MUST* be the AP MAC address */
72         iwe.cmd = SIOCGIWAP;
73         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
74         memcpy(iwe.u.ap_addr.sa_data, network->bssid, ETH_ALEN);
75         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN);
76
77         /* Remaining entries will be displayed in the order we provide them */
78
79         /* Add the ESSID */
80         iwe.cmd = SIOCGIWESSID;
81         iwe.u.data.flags = 1;
82         iwe.u.data.length = min(network->ssid_len, (u8) 32);
83         start = iwe_stream_add_point(info, start, stop,
84                                      &iwe, network->ssid);
85
86         /* Add the protocol name */
87         iwe.cmd = SIOCGIWNAME;
88         snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11%s",
89                  libipw_modes[network->mode]);
90         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN);
91
92         /* Add mode */
93         iwe.cmd = SIOCGIWMODE;
94         if (network->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
95                 if (network->capability & WLAN_CAPABILITY_ESS)
96                         iwe.u.mode = IW_MODE_MASTER;
97                 else
98                         iwe.u.mode = IW_MODE_ADHOC;
99
100                 start = iwe_stream_add_event(info, start, stop,
101                                              &iwe, IW_EV_UINT_LEN);
102         }
103
104         /* Add channel and frequency */
105         /* Note : userspace automatically computes channel using iwrange */
106         iwe.cmd = SIOCGIWFREQ;
107         iwe.u.freq.m = libipw_channel_to_freq(ieee, network->channel);
108         iwe.u.freq.e = 6;
109         iwe.u.freq.i = 0;
110         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_FREQ_LEN);
111
112         /* Add encryption capability */
113         iwe.cmd = SIOCGIWENCODE;
114         if (network->capability & WLAN_CAPABILITY_PRIVACY)
115                 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
116         else
117                 iwe.u.data.flags = IW_ENCODE_DISABLED;
118         iwe.u.data.length = 0;
119         start = iwe_stream_add_point(info, start, stop,
120                                      &iwe, network->ssid);
121
122         /* Add basic and extended rates */
123         /* Rate : stuffing multiple values in a single event require a bit
124          * more of magic - Jean II */
125         current_val = start + iwe_stream_lcp_len(info);
126         iwe.cmd = SIOCGIWRATE;
127         /* Those two flags are ignored... */
128         iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
129
130         for (i = 0, j = 0; i < network->rates_len;) {
131                 if (j < network->rates_ex_len &&
132                     ((network->rates_ex[j] & 0x7F) <
133                      (network->rates[i] & 0x7F)))
134                         rate = network->rates_ex[j++] & 0x7F;
135                 else
136                         rate = network->rates[i++] & 0x7F;
137                 /* Bit rate given in 500 kb/s units (+ 0x80) */
138                 iwe.u.bitrate.value = ((rate & 0x7f) * 500000);
139                 /* Add new value to event */
140                 current_val = iwe_stream_add_value(info, start, current_val,
141                                                    stop, &iwe, IW_EV_PARAM_LEN);
142         }
143         for (; j < network->rates_ex_len; j++) {
144                 rate = network->rates_ex[j] & 0x7F;
145                 /* Bit rate given in 500 kb/s units (+ 0x80) */
146                 iwe.u.bitrate.value = ((rate & 0x7f) * 500000);
147                 /* Add new value to event */
148                 current_val = iwe_stream_add_value(info, start, current_val,
149                                                    stop, &iwe, IW_EV_PARAM_LEN);
150         }
151         /* Check if we added any rate */
152         if ((current_val - start) > iwe_stream_lcp_len(info))
153                 start = current_val;
154
155         /* Add quality statistics */
156         iwe.cmd = IWEVQUAL;
157         iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
158             IW_QUAL_NOISE_UPDATED;
159
160         if (!(network->stats.mask & LIBIPW_STATMASK_RSSI)) {
161                 iwe.u.qual.updated |= IW_QUAL_QUAL_INVALID |
162                     IW_QUAL_LEVEL_INVALID;
163                 iwe.u.qual.qual = 0;
164         } else {
165                 if (ieee->perfect_rssi == ieee->worst_rssi)
166                         iwe.u.qual.qual = 100;
167                 else
168                         iwe.u.qual.qual =
169                             (100 *
170                              (ieee->perfect_rssi - ieee->worst_rssi) *
171                              (ieee->perfect_rssi - ieee->worst_rssi) -
172                              (ieee->perfect_rssi - network->stats.rssi) *
173                              (15 * (ieee->perfect_rssi - ieee->worst_rssi) +
174                               62 * (ieee->perfect_rssi -
175                                     network->stats.rssi))) /
176                             ((ieee->perfect_rssi -
177                               ieee->worst_rssi) * (ieee->perfect_rssi -
178                                                    ieee->worst_rssi));
179                 if (iwe.u.qual.qual > 100)
180                         iwe.u.qual.qual = 100;
181                 else if (iwe.u.qual.qual < 1)
182                         iwe.u.qual.qual = 0;
183         }
184
185         if (!(network->stats.mask & LIBIPW_STATMASK_NOISE)) {
186                 iwe.u.qual.updated |= IW_QUAL_NOISE_INVALID;
187                 iwe.u.qual.noise = 0;
188         } else {
189                 iwe.u.qual.noise = network->stats.noise;
190         }
191
192         if (!(network->stats.mask & LIBIPW_STATMASK_SIGNAL)) {
193                 iwe.u.qual.updated |= IW_QUAL_LEVEL_INVALID;
194                 iwe.u.qual.level = 0;
195         } else {
196                 iwe.u.qual.level = network->stats.signal;
197         }
198
199         start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN);
200
201         iwe.cmd = IWEVCUSTOM;
202         p = custom;
203
204         iwe.u.data.length = p - custom;
205         if (iwe.u.data.length)
206                 start = iwe_stream_add_point(info, start, stop, &iwe, custom);
207
208         memset(&iwe, 0, sizeof(iwe));
209         if (network->wpa_ie_len) {
210                 char buf[MAX_WPA_IE_LEN];
211                 memcpy(buf, network->wpa_ie, network->wpa_ie_len);
212                 iwe.cmd = IWEVGENIE;
213                 iwe.u.data.length = network->wpa_ie_len;
214                 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
215         }
216
217         memset(&iwe, 0, sizeof(iwe));
218         if (network->rsn_ie_len) {
219                 char buf[MAX_WPA_IE_LEN];
220                 memcpy(buf, network->rsn_ie, network->rsn_ie_len);
221                 iwe.cmd = IWEVGENIE;
222                 iwe.u.data.length = network->rsn_ie_len;
223                 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
224         }
225
226         /* Add EXTRA: Age to display seconds since last beacon/probe response
227          * for given network. */
228         iwe.cmd = IWEVCUSTOM;
229         p = custom;
230         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
231                       " Last beacon: %ums ago",
232                       elapsed_jiffies_msecs(network->last_scanned));
233         iwe.u.data.length = p - custom;
234         if (iwe.u.data.length)
235                 start = iwe_stream_add_point(info, start, stop, &iwe, custom);
236
237         /* Add spectrum management information */
238         iwe.cmd = -1;
239         p = custom;
240         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Channel flags: ");
241
242         if (libipw_get_channel_flags(ieee, network->channel) &
243             LIBIPW_CH_INVALID) {
244                 iwe.cmd = IWEVCUSTOM;
245                 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), "INVALID ");
246         }
247
248         if (libipw_get_channel_flags(ieee, network->channel) &
249             LIBIPW_CH_RADAR_DETECT) {
250                 iwe.cmd = IWEVCUSTOM;
251                 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), "DFS ");
252         }
253
254         if (iwe.cmd == IWEVCUSTOM) {
255                 iwe.u.data.length = p - custom;
256                 start = iwe_stream_add_point(info, start, stop, &iwe, custom);
257         }
258
259         return start;
260 }
261
262 #define SCAN_ITEM_SIZE 128
263
264 int libipw_wx_get_scan(struct libipw_device *ieee,
265                           struct iw_request_info *info,
266                           union iwreq_data *wrqu, char *extra)
267 {
268         struct libipw_network *network;
269         unsigned long flags;
270         int err = 0;
271
272         char *ev = extra;
273         char *stop = ev + wrqu->data.length;
274         int i = 0;
275         DECLARE_SSID_BUF(ssid);
276
277         LIBIPW_DEBUG_WX("Getting scan\n");
278
279         spin_lock_irqsave(&ieee->lock, flags);
280
281         list_for_each_entry(network, &ieee->network_list, list) {
282                 i++;
283                 if (stop - ev < SCAN_ITEM_SIZE) {
284                         err = -E2BIG;
285                         break;
286                 }
287
288                 if (ieee->scan_age == 0 ||
289                     time_after(network->last_scanned + ieee->scan_age, jiffies))
290                         ev = libipw_translate_scan(ieee, ev, stop, network,
291                                                       info);
292                 else {
293                         LIBIPW_DEBUG_SCAN("Not showing network '%s ("
294                                              "%pM)' due to age (%ums).\n",
295                                              print_ssid(ssid, network->ssid,
296                                                          network->ssid_len),
297                                              network->bssid,
298                                              elapsed_jiffies_msecs(
299                                                        network->last_scanned));
300                 }
301         }
302
303         spin_unlock_irqrestore(&ieee->lock, flags);
304
305         wrqu->data.length = ev - extra;
306         wrqu->data.flags = 0;
307
308         LIBIPW_DEBUG_WX("exit: %d networks returned.\n", i);
309
310         return err;
311 }
312
313 int libipw_wx_set_encode(struct libipw_device *ieee,
314                             struct iw_request_info *info,
315                             union iwreq_data *wrqu, char *keybuf)
316 {
317         struct iw_point *erq = &(wrqu->encoding);
318         struct net_device *dev = ieee->dev;
319         struct libipw_security sec = {
320                 .flags = 0
321         };
322         int i, key, key_provided, len;
323         struct lib80211_crypt_data **crypt;
324         int host_crypto = ieee->host_encrypt || ieee->host_decrypt;
325         DECLARE_SSID_BUF(ssid);
326
327         LIBIPW_DEBUG_WX("SET_ENCODE\n");
328
329         key = erq->flags & IW_ENCODE_INDEX;
330         if (key) {
331                 if (key > WEP_KEYS)
332                         return -EINVAL;
333                 key--;
334                 key_provided = 1;
335         } else {
336                 key_provided = 0;
337                 key = ieee->crypt_info.tx_keyidx;
338         }
339
340         LIBIPW_DEBUG_WX("Key: %d [%s]\n", key, key_provided ?
341                            "provided" : "default");
342
343         crypt = &ieee->crypt_info.crypt[key];
344
345         if (erq->flags & IW_ENCODE_DISABLED) {
346                 if (key_provided && *crypt) {
347                         LIBIPW_DEBUG_WX("Disabling encryption on key %d.\n",
348                                            key);
349                         lib80211_crypt_delayed_deinit(&ieee->crypt_info, crypt);
350                 } else
351                         LIBIPW_DEBUG_WX("Disabling encryption.\n");
352
353                 /* Check all the keys to see if any are still configured,
354                  * and if no key index was provided, de-init them all */
355                 for (i = 0; i < WEP_KEYS; i++) {
356                         if (ieee->crypt_info.crypt[i] != NULL) {
357                                 if (key_provided)
358                                         break;
359                                 lib80211_crypt_delayed_deinit(&ieee->crypt_info,
360                                                                &ieee->crypt_info.crypt[i]);
361                         }
362                 }
363
364                 if (i == WEP_KEYS) {
365                         sec.enabled = 0;
366                         sec.encrypt = 0;
367                         sec.level = SEC_LEVEL_0;
368                         sec.flags |= SEC_ENABLED | SEC_LEVEL | SEC_ENCRYPT;
369                 }
370
371                 goto done;
372         }
373
374         sec.enabled = 1;
375         sec.encrypt = 1;
376         sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
377
378         if (*crypt != NULL && (*crypt)->ops != NULL &&
379             strcmp((*crypt)->ops->name, "WEP") != 0) {
380                 /* changing to use WEP; deinit previously used algorithm
381                  * on this key */
382                 lib80211_crypt_delayed_deinit(&ieee->crypt_info, crypt);
383         }
384
385         if (*crypt == NULL && host_crypto) {
386                 struct lib80211_crypt_data *new_crypt;
387
388                 /* take WEP into use */
389                 new_crypt = kzalloc(sizeof(struct lib80211_crypt_data),
390                                     GFP_KERNEL);
391                 if (new_crypt == NULL)
392                         return -ENOMEM;
393                 new_crypt->ops = lib80211_get_crypto_ops("WEP");
394                 if (!new_crypt->ops) {
395                         request_module("lib80211_crypt_wep");
396                         new_crypt->ops = lib80211_get_crypto_ops("WEP");
397                 }
398
399                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
400                         new_crypt->priv = new_crypt->ops->init(key);
401
402                 if (!new_crypt->ops || !new_crypt->priv) {
403                         kfree(new_crypt);
404                         new_crypt = NULL;
405
406                         printk(KERN_WARNING "%s: could not initialize WEP: "
407                                "load module lib80211_crypt_wep\n", dev->name);
408                         return -EOPNOTSUPP;
409                 }
410                 *crypt = new_crypt;
411         }
412
413         /* If a new key was provided, set it up */
414         if (erq->length > 0) {
415                 len = erq->length <= 5 ? 5 : 13;
416                 memcpy(sec.keys[key], keybuf, erq->length);
417                 if (len > erq->length)
418                         memset(sec.keys[key] + erq->length, 0,
419                                len - erq->length);
420                 LIBIPW_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
421                                    key, print_ssid(ssid, sec.keys[key], len),
422                                    erq->length, len);
423                 sec.key_sizes[key] = len;
424                 if (*crypt)
425                         (*crypt)->ops->set_key(sec.keys[key], len, NULL,
426                                                (*crypt)->priv);
427                 sec.flags |= (1 << key);
428                 /* This ensures a key will be activated if no key is
429                  * explicitly set */
430                 if (key == sec.active_key)
431                         sec.flags |= SEC_ACTIVE_KEY;
432
433         } else {
434                 if (host_crypto) {
435                         len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN,
436                                                      NULL, (*crypt)->priv);
437                         if (len == 0) {
438                                 /* Set a default key of all 0 */
439                                 LIBIPW_DEBUG_WX("Setting key %d to all "
440                                                    "zero.\n", key);
441                                 memset(sec.keys[key], 0, 13);
442                                 (*crypt)->ops->set_key(sec.keys[key], 13, NULL,
443                                                        (*crypt)->priv);
444                                 sec.key_sizes[key] = 13;
445                                 sec.flags |= (1 << key);
446                         }
447                 }
448                 /* No key data - just set the default TX key index */
449                 if (key_provided) {
450                         LIBIPW_DEBUG_WX("Setting key %d to default Tx "
451                                            "key.\n", key);
452                         ieee->crypt_info.tx_keyidx = key;
453                         sec.active_key = key;
454                         sec.flags |= SEC_ACTIVE_KEY;
455                 }
456         }
457         if (erq->flags & (IW_ENCODE_OPEN | IW_ENCODE_RESTRICTED)) {
458                 ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED);
459                 sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN :
460                     WLAN_AUTH_SHARED_KEY;
461                 sec.flags |= SEC_AUTH_MODE;
462                 LIBIPW_DEBUG_WX("Auth: %s\n",
463                                    sec.auth_mode == WLAN_AUTH_OPEN ?
464                                    "OPEN" : "SHARED KEY");
465         }
466
467         /* For now we just support WEP, so only set that security level...
468          * TODO: When WPA is added this is one place that needs to change */
469         sec.flags |= SEC_LEVEL;
470         sec.level = SEC_LEVEL_1;        /* 40 and 104 bit WEP */
471         sec.encode_alg[key] = SEC_ALG_WEP;
472
473       done:
474         if (ieee->set_security)
475                 ieee->set_security(dev, &sec);
476
477         /* Do not reset port if card is in Managed mode since resetting will
478          * generate new IEEE 802.11 authentication which may end up in looping
479          * with IEEE 802.1X.  If your hardware requires a reset after WEP
480          * configuration (for example... Prism2), implement the reset_port in
481          * the callbacks structures used to initialize the 802.11 stack. */
482         if (ieee->reset_on_keychange &&
483             ieee->iw_mode != IW_MODE_INFRA &&
484             ieee->reset_port && ieee->reset_port(dev)) {
485                 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
486                 return -EINVAL;
487         }
488         return 0;
489 }
490
491 int libipw_wx_get_encode(struct libipw_device *ieee,
492                             struct iw_request_info *info,
493                             union iwreq_data *wrqu, char *keybuf)
494 {
495         struct iw_point *erq = &(wrqu->encoding);
496         int len, key;
497         struct lib80211_crypt_data *crypt;
498         struct libipw_security *sec = &ieee->sec;
499
500         LIBIPW_DEBUG_WX("GET_ENCODE\n");
501
502         key = erq->flags & IW_ENCODE_INDEX;
503         if (key) {
504                 if (key > WEP_KEYS)
505                         return -EINVAL;
506                 key--;
507         } else
508                 key = ieee->crypt_info.tx_keyidx;
509
510         crypt = ieee->crypt_info.crypt[key];
511         erq->flags = key + 1;
512
513         if (!sec->enabled) {
514                 erq->length = 0;
515                 erq->flags |= IW_ENCODE_DISABLED;
516                 return 0;
517         }
518
519         len = sec->key_sizes[key];
520         memcpy(keybuf, sec->keys[key], len);
521
522         erq->length = len;
523         erq->flags |= IW_ENCODE_ENABLED;
524
525         if (ieee->open_wep)
526                 erq->flags |= IW_ENCODE_OPEN;
527         else
528                 erq->flags |= IW_ENCODE_RESTRICTED;
529
530         return 0;
531 }
532
533 int libipw_wx_set_encodeext(struct libipw_device *ieee,
534                                struct iw_request_info *info,
535                                union iwreq_data *wrqu, char *extra)
536 {
537         struct net_device *dev = ieee->dev;
538         struct iw_point *encoding = &wrqu->encoding;
539         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
540         int i, idx, ret = 0;
541         int group_key = 0;
542         const char *alg, *module;
543         struct lib80211_crypto_ops *ops;
544         struct lib80211_crypt_data **crypt;
545
546         struct libipw_security sec = {
547                 .flags = 0,
548         };
549
550         idx = encoding->flags & IW_ENCODE_INDEX;
551         if (idx) {
552                 if (idx < 1 || idx > WEP_KEYS)
553                         return -EINVAL;
554                 idx--;
555         } else
556                 idx = ieee->crypt_info.tx_keyidx;
557
558         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
559                 crypt = &ieee->crypt_info.crypt[idx];
560                 group_key = 1;
561         } else {
562                 /* some Cisco APs use idx>0 for unicast in dynamic WEP */
563                 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
564                         return -EINVAL;
565                 if (ieee->iw_mode == IW_MODE_INFRA)
566                         crypt = &ieee->crypt_info.crypt[idx];
567                 else
568                         return -EINVAL;
569         }
570
571         sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
572         if ((encoding->flags & IW_ENCODE_DISABLED) ||
573             ext->alg == IW_ENCODE_ALG_NONE) {
574                 if (*crypt)
575                         lib80211_crypt_delayed_deinit(&ieee->crypt_info, crypt);
576
577                 for (i = 0; i < WEP_KEYS; i++)
578                         if (ieee->crypt_info.crypt[i] != NULL)
579                                 break;
580
581                 if (i == WEP_KEYS) {
582                         sec.enabled = 0;
583                         sec.encrypt = 0;
584                         sec.level = SEC_LEVEL_0;
585                         sec.flags |= SEC_LEVEL;
586                 }
587                 goto done;
588         }
589
590         sec.enabled = 1;
591         sec.encrypt = 1;
592
593         if (group_key ? !ieee->host_mc_decrypt :
594             !(ieee->host_encrypt || ieee->host_decrypt ||
595               ieee->host_encrypt_msdu))
596                 goto skip_host_crypt;
597
598         switch (ext->alg) {
599         case IW_ENCODE_ALG_WEP:
600                 alg = "WEP";
601                 module = "lib80211_crypt_wep";
602                 break;
603         case IW_ENCODE_ALG_TKIP:
604                 alg = "TKIP";
605                 module = "lib80211_crypt_tkip";
606                 break;
607         case IW_ENCODE_ALG_CCMP:
608                 alg = "CCMP";
609                 module = "lib80211_crypt_ccmp";
610                 break;
611         default:
612                 LIBIPW_DEBUG_WX("%s: unknown crypto alg %d\n",
613                                    dev->name, ext->alg);
614                 ret = -EINVAL;
615                 goto done;
616         }
617
618         ops = lib80211_get_crypto_ops(alg);
619         if (ops == NULL) {
620                 request_module(module);
621                 ops = lib80211_get_crypto_ops(alg);
622         }
623         if (ops == NULL) {
624                 LIBIPW_DEBUG_WX("%s: unknown crypto alg %d\n",
625                                    dev->name, ext->alg);
626                 ret = -EINVAL;
627                 goto done;
628         }
629
630         if (*crypt == NULL || (*crypt)->ops != ops) {
631                 struct lib80211_crypt_data *new_crypt;
632
633                 lib80211_crypt_delayed_deinit(&ieee->crypt_info, crypt);
634
635                 new_crypt = kzalloc(sizeof(*new_crypt), GFP_KERNEL);
636                 if (new_crypt == NULL) {
637                         ret = -ENOMEM;
638                         goto done;
639                 }
640                 new_crypt->ops = ops;
641                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
642                         new_crypt->priv = new_crypt->ops->init(idx);
643                 if (new_crypt->priv == NULL) {
644                         kfree(new_crypt);
645                         ret = -EINVAL;
646                         goto done;
647                 }
648                 *crypt = new_crypt;
649         }
650
651         if (ext->key_len > 0 && (*crypt)->ops->set_key &&
652             (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
653                                    (*crypt)->priv) < 0) {
654                 LIBIPW_DEBUG_WX("%s: key setting failed\n", dev->name);
655                 ret = -EINVAL;
656                 goto done;
657         }
658
659       skip_host_crypt:
660         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
661                 ieee->crypt_info.tx_keyidx = idx;
662                 sec.active_key = idx;
663                 sec.flags |= SEC_ACTIVE_KEY;
664         }
665
666         if (ext->alg != IW_ENCODE_ALG_NONE) {
667                 memcpy(sec.keys[idx], ext->key, ext->key_len);
668                 sec.key_sizes[idx] = ext->key_len;
669                 sec.flags |= (1 << idx);
670                 if (ext->alg == IW_ENCODE_ALG_WEP) {
671                         sec.encode_alg[idx] = SEC_ALG_WEP;
672                         sec.flags |= SEC_LEVEL;
673                         sec.level = SEC_LEVEL_1;
674                 } else if (ext->alg == IW_ENCODE_ALG_TKIP) {
675                         sec.encode_alg[idx] = SEC_ALG_TKIP;
676                         sec.flags |= SEC_LEVEL;
677                         sec.level = SEC_LEVEL_2;
678                 } else if (ext->alg == IW_ENCODE_ALG_CCMP) {
679                         sec.encode_alg[idx] = SEC_ALG_CCMP;
680                         sec.flags |= SEC_LEVEL;
681                         sec.level = SEC_LEVEL_3;
682                 }
683                 /* Don't set sec level for group keys. */
684                 if (group_key)
685                         sec.flags &= ~SEC_LEVEL;
686         }
687       done:
688         if (ieee->set_security)
689                 ieee->set_security(ieee->dev, &sec);
690
691         /*
692          * Do not reset port if card is in Managed mode since resetting will
693          * generate new IEEE 802.11 authentication which may end up in looping
694          * with IEEE 802.1X. If your hardware requires a reset after WEP
695          * configuration (for example... Prism2), implement the reset_port in
696          * the callbacks structures used to initialize the 802.11 stack.
697          */
698         if (ieee->reset_on_keychange &&
699             ieee->iw_mode != IW_MODE_INFRA &&
700             ieee->reset_port && ieee->reset_port(dev)) {
701                 LIBIPW_DEBUG_WX("%s: reset_port failed\n", dev->name);
702                 return -EINVAL;
703         }
704
705         return ret;
706 }
707
708 int libipw_wx_get_encodeext(struct libipw_device *ieee,
709                                struct iw_request_info *info,
710                                union iwreq_data *wrqu, char *extra)
711 {
712         struct iw_point *encoding = &wrqu->encoding;
713         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
714         struct libipw_security *sec = &ieee->sec;
715         int idx, max_key_len;
716
717         max_key_len = encoding->length - sizeof(*ext);
718         if (max_key_len < 0)
719                 return -EINVAL;
720
721         idx = encoding->flags & IW_ENCODE_INDEX;
722         if (idx) {
723                 if (idx < 1 || idx > WEP_KEYS)
724                         return -EINVAL;
725                 idx--;
726         } else
727                 idx = ieee->crypt_info.tx_keyidx;
728
729         if (!(ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) &&
730             ext->alg != IW_ENCODE_ALG_WEP)
731                 if (idx != 0 || ieee->iw_mode != IW_MODE_INFRA)
732                         return -EINVAL;
733
734         encoding->flags = idx + 1;
735         memset(ext, 0, sizeof(*ext));
736
737         if (!sec->enabled) {
738                 ext->alg = IW_ENCODE_ALG_NONE;
739                 ext->key_len = 0;
740                 encoding->flags |= IW_ENCODE_DISABLED;
741         } else {
742                 if (sec->encode_alg[idx] == SEC_ALG_WEP)
743                         ext->alg = IW_ENCODE_ALG_WEP;
744                 else if (sec->encode_alg[idx] == SEC_ALG_TKIP)
745                         ext->alg = IW_ENCODE_ALG_TKIP;
746                 else if (sec->encode_alg[idx] == SEC_ALG_CCMP)
747                         ext->alg = IW_ENCODE_ALG_CCMP;
748                 else
749                         return -EINVAL;
750
751                 ext->key_len = sec->key_sizes[idx];
752                 memcpy(ext->key, sec->keys[idx], ext->key_len);
753                 encoding->flags |= IW_ENCODE_ENABLED;
754                 if (ext->key_len &&
755                     (ext->alg == IW_ENCODE_ALG_TKIP ||
756                      ext->alg == IW_ENCODE_ALG_CCMP))
757                         ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
758
759         }
760
761         return 0;
762 }
763
764 EXPORT_SYMBOL(libipw_wx_set_encodeext);
765 EXPORT_SYMBOL(libipw_wx_get_encodeext);
766
767 EXPORT_SYMBOL(libipw_wx_get_scan);
768 EXPORT_SYMBOL(libipw_wx_set_encode);
769 EXPORT_SYMBOL(libipw_wx_get_encode);