ixgb: Increment version to 1.0.112-k2
[linux-2.6] / drivers / net / wireless / bcm43xx / bcm43xx_wx.c
1 /*
2
3   Broadcom BCM43xx wireless driver
4
5   Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>,
6                      Stefano Brivio <st3@riseup.net>
7                      Michael Buesch <mbuesch@freenet.de>
8                      Danny van Dyk <kugelfang@gentoo.org>
9                      Andreas Jaggi <andreas.jaggi@waterwave.ch>
10
11   Some parts of the code in this file are derived from the ipw2200
12   driver  Copyright(c) 2003 - 2004 Intel Corporation.
13
14   This program is free software; you can redistribute it and/or modify
15   it under the terms of the GNU General Public License as published by
16   the Free Software Foundation; either version 2 of the License, or
17   (at your option) any later version.
18
19   This program is distributed in the hope that it will be useful,
20   but WITHOUT ANY WARRANTY; without even the implied warranty of
21   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22   GNU General Public License for more details.
23
24   You should have received a copy of the GNU General Public License
25   along with this program; see the file COPYING.  If not, write to
26   the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
27   Boston, MA 02110-1301, USA.
28
29 */
30
31 #include <linux/wireless.h>
32 #include <net/iw_handler.h>
33 #include <net/ieee80211softmac.h>
34 #include <net/ieee80211softmac_wx.h>
35 #include <linux/capability.h>
36 #include <linux/sched.h> /* for capable() */
37 #include <linux/delay.h>
38
39 #include "bcm43xx.h"
40 #include "bcm43xx_wx.h"
41 #include "bcm43xx_main.h"
42 #include "bcm43xx_radio.h"
43 #include "bcm43xx_phy.h"
44
45
46 /* The WIRELESS_EXT version, which is implemented by this driver. */
47 #define BCM43xx_WX_VERSION      18
48
49 #define MAX_WX_STRING           80
50 /* FIXME: the next line is a guess as to what the maximum RSSI value might be */
51 #define RX_RSSI_MAX             60
52
53
54 static int bcm43xx_wx_get_name(struct net_device *net_dev,
55                                struct iw_request_info *info,
56                                union iwreq_data *data,
57                                char *extra)
58 {
59         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
60         int i;
61         struct bcm43xx_phyinfo *phy;
62         char suffix[7] = { 0 };
63         int have_a = 0, have_b = 0, have_g = 0;
64
65         mutex_lock(&bcm->mutex);
66         for (i = 0; i < bcm->nr_80211_available; i++) {
67                 phy = &(bcm->core_80211_ext[i].phy);
68                 switch (phy->type) {
69                 case BCM43xx_PHYTYPE_A:
70                         have_a = 1;
71                         break;
72                 case BCM43xx_PHYTYPE_G:
73                         have_g = 1;
74                 case BCM43xx_PHYTYPE_B:
75                         have_b = 1;
76                         break;
77                 default:
78                         assert(0);
79                 }
80         }
81         mutex_unlock(&bcm->mutex);
82
83         i = 0;
84         if (have_a) {
85                 suffix[i++] = 'a';
86                 suffix[i++] = '/';
87         }
88         if (have_b) {
89                 suffix[i++] = 'b';
90                 suffix[i++] = '/';
91         }
92         if (have_g) {
93                 suffix[i++] = 'g';
94                 suffix[i++] = '/';
95         }
96         if (i != 0) 
97                 suffix[i - 1] = '\0';
98
99         snprintf(data->name, IFNAMSIZ, "IEEE 802.11%s", suffix);
100
101         return 0;
102 }
103
104 static int bcm43xx_wx_set_channelfreq(struct net_device *net_dev,
105                                       struct iw_request_info *info,
106                                       union iwreq_data *data,
107                                       char *extra)
108 {
109         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
110         unsigned long flags;
111         u8 channel;
112         int freq;
113         int err = -EINVAL;
114
115         mutex_lock(&bcm->mutex);
116         spin_lock_irqsave(&bcm->irq_lock, flags);
117
118         if ((data->freq.m >= 0) && (data->freq.m <= 1000)) {
119                 channel = data->freq.m;
120                 freq = bcm43xx_channel_to_freq(bcm, channel);
121         } else {
122                 channel = bcm43xx_freq_to_channel(bcm, data->freq.m);
123                 freq = data->freq.m;
124         }
125         if (!ieee80211_is_valid_channel(bcm->ieee, channel))
126                 goto out_unlock;
127         if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) {
128                 //ieee80211softmac_disassoc(softmac, $REASON);
129                 bcm43xx_mac_suspend(bcm);
130                 err = bcm43xx_radio_selectchannel(bcm, channel, 0);
131                 bcm43xx_mac_enable(bcm);
132         } else {
133                 bcm43xx_current_radio(bcm)->initial_channel = channel;
134                 err = 0;
135         }
136 out_unlock:
137         spin_unlock_irqrestore(&bcm->irq_lock, flags);
138         mutex_unlock(&bcm->mutex);
139
140         return err;
141 }
142
143 static int bcm43xx_wx_get_channelfreq(struct net_device *net_dev,
144                                       struct iw_request_info *info,
145                                       union iwreq_data *data,
146                                       char *extra)
147 {
148         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
149         struct bcm43xx_radioinfo *radio;
150         int err = -ENODEV;
151         u16 channel;
152
153         mutex_lock(&bcm->mutex);
154         radio = bcm43xx_current_radio(bcm);
155         channel = radio->channel;
156         if (channel == 0xFF) {
157                 channel = radio->initial_channel;
158                 if (channel == 0xFF)
159                         goto out_unlock;
160         }
161         assert(channel > 0 && channel <= 1000);
162         data->freq.e = 1;
163         data->freq.m = bcm43xx_channel_to_freq(bcm, channel) * 100000;
164         data->freq.flags = 1;
165
166         err = 0;
167 out_unlock:
168         mutex_unlock(&bcm->mutex);
169
170         return err;
171 }
172
173 static int bcm43xx_wx_set_mode(struct net_device *net_dev,
174                                struct iw_request_info *info,
175                                union iwreq_data *data,
176                                char *extra)
177 {
178         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
179         unsigned long flags;
180         int mode;
181
182         mode = data->mode;
183         if (mode == IW_MODE_AUTO)
184                 mode = BCM43xx_INITIAL_IWMODE;
185
186         mutex_lock(&bcm->mutex);
187         spin_lock_irqsave(&bcm->irq_lock, flags);
188         if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) {
189                 if (bcm->ieee->iw_mode != mode)
190                         bcm43xx_set_iwmode(bcm, mode);
191         } else
192                 bcm->ieee->iw_mode = mode;
193         spin_unlock_irqrestore(&bcm->irq_lock, flags);
194         mutex_unlock(&bcm->mutex);
195
196         return 0;
197 }
198
199 static int bcm43xx_wx_get_mode(struct net_device *net_dev,
200                                struct iw_request_info *info,
201                                union iwreq_data *data,
202                                char *extra)
203 {
204         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
205
206         mutex_lock(&bcm->mutex);
207         data->mode = bcm->ieee->iw_mode;
208         mutex_unlock(&bcm->mutex);
209
210         return 0;
211 }
212
213 static int bcm43xx_wx_get_rangeparams(struct net_device *net_dev,
214                                       struct iw_request_info *info,
215                                       union iwreq_data *data,
216                                       char *extra)
217 {
218         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
219         struct iw_range *range = (struct iw_range *)extra;
220         const struct ieee80211_geo *geo;
221         int i, j;
222         struct bcm43xx_phyinfo *phy;
223
224         data->data.length = sizeof(*range);
225         memset(range, 0, sizeof(*range));
226
227         //TODO: What about 802.11b?
228         /* 54Mb/s == ~27Mb/s payload throughput (802.11g) */
229         range->throughput = 27 * 1000 * 1000;
230
231         range->max_qual.qual = 100;
232         range->max_qual.level = 152; /* set floor at -104 dBm (152 - 256) */
233         range->max_qual.noise = 152;
234         range->max_qual.updated = IW_QUAL_ALL_UPDATED;
235
236         range->avg_qual.qual = 50;
237         range->avg_qual.level = 0;
238         range->avg_qual.noise = 0;
239         range->avg_qual.updated = IW_QUAL_ALL_UPDATED;
240
241         range->min_rts = BCM43xx_MIN_RTS_THRESHOLD;
242         range->max_rts = BCM43xx_MAX_RTS_THRESHOLD;
243         range->min_frag = MIN_FRAG_THRESHOLD;
244         range->max_frag = MAX_FRAG_THRESHOLD;
245
246         range->encoding_size[0] = 5;
247         range->encoding_size[1] = 13;
248         range->num_encoding_sizes = 2;
249         range->max_encoding_tokens = WEP_KEYS;
250
251         range->we_version_compiled = WIRELESS_EXT;
252         range->we_version_source = BCM43xx_WX_VERSION;
253
254         range->enc_capa = IW_ENC_CAPA_WPA |
255                           IW_ENC_CAPA_WPA2 |
256                           IW_ENC_CAPA_CIPHER_TKIP |
257                           IW_ENC_CAPA_CIPHER_CCMP;
258
259         mutex_lock(&bcm->mutex);
260         phy = bcm43xx_current_phy(bcm);
261
262         range->num_bitrates = 0;
263         i = 0;
264         if (phy->type == BCM43xx_PHYTYPE_A ||
265             phy->type == BCM43xx_PHYTYPE_G) {
266                 range->num_bitrates = 8;
267                 range->bitrate[i++] = IEEE80211_OFDM_RATE_6MB;
268                 range->bitrate[i++] = IEEE80211_OFDM_RATE_9MB;
269                 range->bitrate[i++] = IEEE80211_OFDM_RATE_12MB;
270                 range->bitrate[i++] = IEEE80211_OFDM_RATE_18MB;
271                 range->bitrate[i++] = IEEE80211_OFDM_RATE_24MB;
272                 range->bitrate[i++] = IEEE80211_OFDM_RATE_36MB;
273                 range->bitrate[i++] = IEEE80211_OFDM_RATE_48MB;
274                 range->bitrate[i++] = IEEE80211_OFDM_RATE_54MB;
275         }
276         if (phy->type == BCM43xx_PHYTYPE_B ||
277             phy->type == BCM43xx_PHYTYPE_G) {
278                 range->num_bitrates += 4;
279                 range->bitrate[i++] = IEEE80211_CCK_RATE_1MB;
280                 range->bitrate[i++] = IEEE80211_CCK_RATE_2MB;
281                 range->bitrate[i++] = IEEE80211_CCK_RATE_5MB;
282                 range->bitrate[i++] = IEEE80211_CCK_RATE_11MB;
283         }
284
285         geo = ieee80211_get_geo(bcm->ieee);
286         range->num_channels = geo->a_channels + geo->bg_channels;
287         j = 0;
288         for (i = 0; i < geo->a_channels; i++) {
289                 if (j == IW_MAX_FREQUENCIES)
290                         break;
291                 range->freq[j].i = j + 1;
292                 range->freq[j].m = geo->a[i].freq;//FIXME?
293                 range->freq[j].e = 1;
294                 j++;
295         }
296         for (i = 0; i < geo->bg_channels; i++) {
297                 if (j == IW_MAX_FREQUENCIES)
298                         break;
299                 range->freq[j].i = j + 1;
300                 range->freq[j].m = geo->bg[i].freq;//FIXME?
301                 range->freq[j].e = 1;
302                 j++;
303         }
304         range->num_frequency = j;
305
306         mutex_unlock(&bcm->mutex);
307
308         return 0;
309 }
310
311 static int bcm43xx_wx_set_nick(struct net_device *net_dev,
312                                struct iw_request_info *info,
313                                union iwreq_data *data,
314                                char *extra)
315 {
316         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
317         size_t len;
318
319         mutex_lock(&bcm->mutex);
320         len =  min((size_t)data->data.length, (size_t)IW_ESSID_MAX_SIZE);
321         memcpy(bcm->nick, extra, len);
322         bcm->nick[len] = '\0';
323         mutex_unlock(&bcm->mutex);
324
325         return 0;
326 }
327
328 static int bcm43xx_wx_get_nick(struct net_device *net_dev,
329                                struct iw_request_info *info,
330                                union iwreq_data *data,
331                                char *extra)
332 {
333         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
334         size_t len;
335
336         mutex_lock(&bcm->mutex);
337         len = strlen(bcm->nick) + 1;
338         memcpy(extra, bcm->nick, len);
339         data->data.length = (__u16)len;
340         data->data.flags = 1;
341         mutex_unlock(&bcm->mutex);
342
343         return 0;
344 }
345
346 static int bcm43xx_wx_set_rts(struct net_device *net_dev,
347                               struct iw_request_info *info,
348                               union iwreq_data *data,
349                               char *extra)
350 {
351         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
352         unsigned long flags;
353         int err = -EINVAL;
354
355         mutex_lock(&bcm->mutex);
356         spin_lock_irqsave(&bcm->irq_lock, flags);
357         if (data->rts.disabled) {
358                 bcm->rts_threshold = BCM43xx_MAX_RTS_THRESHOLD;
359                 err = 0;
360         } else {
361                 if (data->rts.value >= BCM43xx_MIN_RTS_THRESHOLD &&
362                     data->rts.value <= BCM43xx_MAX_RTS_THRESHOLD) {
363                         bcm->rts_threshold = data->rts.value;
364                         err = 0;
365                 }
366         }
367         spin_unlock_irqrestore(&bcm->irq_lock, flags);
368         mutex_unlock(&bcm->mutex);
369
370         return err;
371 }
372
373 static int bcm43xx_wx_get_rts(struct net_device *net_dev,
374                               struct iw_request_info *info,
375                               union iwreq_data *data,
376                               char *extra)
377 {
378         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
379
380         mutex_lock(&bcm->mutex);
381         data->rts.value = bcm->rts_threshold;
382         data->rts.fixed = 0;
383         data->rts.disabled = (bcm->rts_threshold == BCM43xx_MAX_RTS_THRESHOLD);
384         mutex_unlock(&bcm->mutex);
385
386         return 0;
387 }
388
389 static int bcm43xx_wx_set_frag(struct net_device *net_dev,
390                                struct iw_request_info *info,
391                                union iwreq_data *data,
392                                char *extra)
393 {
394         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
395         unsigned long flags;
396         int err = -EINVAL;
397
398         mutex_lock(&bcm->mutex);
399         spin_lock_irqsave(&bcm->irq_lock, flags);
400         if (data->frag.disabled) {
401                 bcm->ieee->fts = MAX_FRAG_THRESHOLD;
402                 err = 0;
403         } else {
404                 if (data->frag.value >= MIN_FRAG_THRESHOLD &&
405                     data->frag.value <= MAX_FRAG_THRESHOLD) {
406                         bcm->ieee->fts = data->frag.value & ~0x1;
407                         err = 0;
408                 }
409         }
410         spin_unlock_irqrestore(&bcm->irq_lock, flags);
411         mutex_unlock(&bcm->mutex);
412
413         return err;
414 }
415
416 static int bcm43xx_wx_get_frag(struct net_device *net_dev,
417                                struct iw_request_info *info,
418                                union iwreq_data *data,
419                                char *extra)
420 {
421         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
422
423         mutex_lock(&bcm->mutex);
424         data->frag.value = bcm->ieee->fts;
425         data->frag.fixed = 0;
426         data->frag.disabled = (bcm->ieee->fts == MAX_FRAG_THRESHOLD);
427         mutex_unlock(&bcm->mutex);
428
429         return 0;
430 }
431
432 static int bcm43xx_wx_set_xmitpower(struct net_device *net_dev,
433                                     struct iw_request_info *info,
434                                     union iwreq_data *data,
435                                     char *extra)
436 {
437         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
438         struct bcm43xx_radioinfo *radio;
439         struct bcm43xx_phyinfo *phy;
440         unsigned long flags;
441         int err = -ENODEV;
442         u16 maxpower;
443
444         if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM) {
445                 printk(PFX KERN_ERR "TX power not in dBm.\n");
446                 return -EOPNOTSUPP;
447         }
448
449         mutex_lock(&bcm->mutex);
450         spin_lock_irqsave(&bcm->irq_lock, flags);
451         if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED)
452                 goto out_unlock;
453         radio = bcm43xx_current_radio(bcm);
454         phy = bcm43xx_current_phy(bcm);
455         if (data->txpower.disabled != (!(radio->enabled))) {
456                 if (data->txpower.disabled)
457                         bcm43xx_radio_turn_off(bcm);
458                 else
459                         bcm43xx_radio_turn_on(bcm);
460         }
461         if (data->txpower.value > 0) {
462                 /* desired and maxpower dBm values are in Q5.2 */
463                 if (phy->type == BCM43xx_PHYTYPE_A)
464                         maxpower = bcm->sprom.maxpower_aphy;
465                 else
466                         maxpower = bcm->sprom.maxpower_bgphy;
467                 radio->txpower_desired = limit_value(data->txpower.value << 2,
468                                                      0, maxpower);
469                 bcm43xx_phy_xmitpower(bcm);
470         }
471         err = 0;
472
473 out_unlock:
474         spin_unlock_irqrestore(&bcm->irq_lock, flags);
475         mutex_unlock(&bcm->mutex);
476
477         return err;
478 }
479
480 static int bcm43xx_wx_get_xmitpower(struct net_device *net_dev,
481                                     struct iw_request_info *info,
482                                     union iwreq_data *data,
483                                     char *extra)
484 {
485         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
486         struct bcm43xx_radioinfo *radio;
487         int err = -ENODEV;
488
489         mutex_lock(&bcm->mutex);
490         if (bcm43xx_status(bcm) != BCM43xx_STAT_INITIALIZED)
491                 goto out_unlock;
492         radio = bcm43xx_current_radio(bcm);
493         /* desired dBm value is in Q5.2 */
494         data->txpower.value = radio->txpower_desired >> 2;
495         data->txpower.fixed = 1;
496         data->txpower.flags = IW_TXPOW_DBM;
497         data->txpower.disabled = !(radio->enabled);
498
499         err = 0;
500 out_unlock:
501         mutex_unlock(&bcm->mutex);
502
503         return err;
504 }
505
506 static int bcm43xx_wx_set_encoding(struct net_device *net_dev,
507                                    struct iw_request_info *info,
508                                    union iwreq_data *data,
509                                    char *extra)
510 {
511         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
512         int err;
513
514         err = ieee80211_wx_set_encode(bcm->ieee, info, data, extra);
515
516         return err;
517 }
518
519 static int bcm43xx_wx_set_encodingext(struct net_device *net_dev,
520                                    struct iw_request_info *info,
521                                    union iwreq_data *data,
522                                    char *extra)
523 {
524         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
525         int err;
526
527         err = ieee80211_wx_set_encodeext(bcm->ieee, info, data, extra);
528
529         return err;
530 }
531
532 static int bcm43xx_wx_get_encoding(struct net_device *net_dev,
533                                    struct iw_request_info *info,
534                                    union iwreq_data *data,
535                                    char *extra)
536 {
537         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
538         int err;
539
540         err = ieee80211_wx_get_encode(bcm->ieee, info, data, extra);
541
542         return err;
543 }
544
545 static int bcm43xx_wx_get_encodingext(struct net_device *net_dev,
546                                    struct iw_request_info *info,
547                                    union iwreq_data *data,
548                                    char *extra)
549 {
550         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
551         int err;
552
553         err = ieee80211_wx_get_encodeext(bcm->ieee, info, data, extra);
554
555         return err;
556 }
557
558 static int bcm43xx_wx_set_interfmode(struct net_device *net_dev,
559                                      struct iw_request_info *info,
560                                      union iwreq_data *data,
561                                      char *extra)
562 {
563         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
564         unsigned long flags;
565         int mode, err = 0;
566
567         mode = *((int *)extra);
568         switch (mode) {
569         case 0:
570                 mode = BCM43xx_RADIO_INTERFMODE_NONE;
571                 break;
572         case 1:
573                 mode = BCM43xx_RADIO_INTERFMODE_NONWLAN;
574                 break;
575         case 2:
576                 mode = BCM43xx_RADIO_INTERFMODE_MANUALWLAN;
577                 break;
578         case 3:
579                 mode = BCM43xx_RADIO_INTERFMODE_AUTOWLAN;
580                 break;
581         default:
582                 printk(KERN_ERR PFX "set_interfmode allowed parameters are: "
583                                     "0 => None,  1 => Non-WLAN,  2 => WLAN,  "
584                                     "3 => Auto-WLAN\n");
585                 return -EINVAL;
586         }
587
588         mutex_lock(&bcm->mutex);
589         spin_lock_irqsave(&bcm->irq_lock, flags);
590         if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED) {
591                 err = bcm43xx_radio_set_interference_mitigation(bcm, mode);
592                 if (err) {
593                         printk(KERN_ERR PFX "Interference Mitigation not "
594                                             "supported by device\n");
595                 }
596         } else {
597                 if (mode == BCM43xx_RADIO_INTERFMODE_AUTOWLAN) {
598                         printk(KERN_ERR PFX "Interference Mitigation mode Auto-WLAN "
599                                             "not supported while the interface is down.\n");
600                         err = -ENODEV;
601                 } else
602                         bcm43xx_current_radio(bcm)->interfmode = mode;
603         }
604         spin_unlock_irqrestore(&bcm->irq_lock, flags);
605         mutex_unlock(&bcm->mutex);
606
607         return err;
608 }
609
610 static int bcm43xx_wx_get_interfmode(struct net_device *net_dev,
611                                      struct iw_request_info *info,
612                                      union iwreq_data *data,
613                                      char *extra)
614 {
615         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
616         int mode;
617
618         mutex_lock(&bcm->mutex);
619         mode = bcm43xx_current_radio(bcm)->interfmode;
620         mutex_unlock(&bcm->mutex);
621
622         switch (mode) {
623         case BCM43xx_RADIO_INTERFMODE_NONE:
624                 strncpy(extra, "0 (No Interference Mitigation)", MAX_WX_STRING);
625                 break;
626         case BCM43xx_RADIO_INTERFMODE_NONWLAN:
627                 strncpy(extra, "1 (Non-WLAN Interference Mitigation)", MAX_WX_STRING);
628                 break;
629         case BCM43xx_RADIO_INTERFMODE_MANUALWLAN:
630                 strncpy(extra, "2 (WLAN Interference Mitigation)", MAX_WX_STRING);
631                 break;
632         default:
633                 assert(0);
634         }
635         data->data.length = strlen(extra) + 1;
636
637         return 0;
638 }
639
640 static int bcm43xx_wx_set_shortpreamble(struct net_device *net_dev,
641                                         struct iw_request_info *info,
642                                         union iwreq_data *data,
643                                         char *extra)
644 {
645         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
646         unsigned long flags;
647         int on;
648
649         on = *((int *)extra);
650         mutex_lock(&bcm->mutex);
651         spin_lock_irqsave(&bcm->irq_lock, flags);
652         bcm->short_preamble = !!on;
653         spin_unlock_irqrestore(&bcm->irq_lock, flags);
654         mutex_unlock(&bcm->mutex);
655
656         return 0;
657 }
658
659 static int bcm43xx_wx_get_shortpreamble(struct net_device *net_dev,
660                                         struct iw_request_info *info,
661                                         union iwreq_data *data,
662                                         char *extra)
663 {
664         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
665         int on;
666
667         mutex_lock(&bcm->mutex);
668         on = bcm->short_preamble;
669         mutex_unlock(&bcm->mutex);
670
671         if (on)
672                 strncpy(extra, "1 (Short Preamble enabled)", MAX_WX_STRING);
673         else
674                 strncpy(extra, "0 (Short Preamble disabled)", MAX_WX_STRING);
675         data->data.length = strlen(extra) + 1;
676
677         return 0;
678 }
679
680 static int bcm43xx_wx_set_swencryption(struct net_device *net_dev,
681                                        struct iw_request_info *info,
682                                        union iwreq_data *data,
683                                        char *extra)
684 {
685         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
686         unsigned long flags;
687         int on;
688         
689         on = *((int *)extra);
690
691         mutex_lock(&bcm->mutex);
692         spin_lock_irqsave(&bcm->irq_lock, flags);
693         bcm->ieee->host_encrypt = !!on;
694         bcm->ieee->host_decrypt = !!on;
695         bcm->ieee->host_build_iv = !on;
696         spin_unlock_irqrestore(&bcm->irq_lock, flags);
697         mutex_unlock(&bcm->mutex);
698
699         return 0;
700 }
701
702 static int bcm43xx_wx_get_swencryption(struct net_device *net_dev,
703                                        struct iw_request_info *info,
704                                        union iwreq_data *data,
705                                        char *extra)
706 {
707         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
708         int on;
709
710         mutex_lock(&bcm->mutex);
711         on = bcm->ieee->host_encrypt;
712         mutex_unlock(&bcm->mutex);
713
714         if (on)
715                 strncpy(extra, "1 (SW encryption enabled) ", MAX_WX_STRING);
716         else
717                 strncpy(extra, "0 (SW encryption disabled) ", MAX_WX_STRING);
718         data->data.length = strlen(extra + 1);
719
720         return 0;
721 }
722
723 /* Enough buffer to hold a hexdump of the sprom data. */
724 #define SPROM_BUFFERSIZE        512
725
726 static int sprom2hex(const u16 *sprom, char *dump)
727 {
728         int i, pos = 0;
729
730         for (i = 0; i < BCM43xx_SPROM_SIZE; i++) {
731                 pos += snprintf(dump + pos, SPROM_BUFFERSIZE - pos - 1,
732                                 "%04X", swab16(sprom[i]) & 0xFFFF);
733         }
734
735         return pos + 1;
736 }
737
738 static int hex2sprom(u16 *sprom, const char *dump, unsigned int len)
739 {
740         char tmp[5] = { 0 };
741         int cnt = 0;
742         unsigned long parsed;
743
744         if (len < BCM43xx_SPROM_SIZE * sizeof(u16) * 2)
745                 return -EINVAL;
746         while (cnt < BCM43xx_SPROM_SIZE) {
747                 memcpy(tmp, dump, 4);
748                 dump += 4;
749                 parsed = simple_strtoul(tmp, NULL, 16);
750                 sprom[cnt++] = swab16((u16)parsed);
751         }
752
753         return 0;
754 }
755
756 static int bcm43xx_wx_sprom_read(struct net_device *net_dev,
757                                  struct iw_request_info *info,
758                                  union iwreq_data *data,
759                                  char *extra)
760 {
761         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
762         int err = -EPERM;
763         u16 *sprom;
764         unsigned long flags;
765
766         if (!capable(CAP_SYS_RAWIO))
767                 goto out;
768
769         err = -ENOMEM;
770         sprom = kmalloc(BCM43xx_SPROM_SIZE * sizeof(*sprom),
771                         GFP_KERNEL);
772         if (!sprom)
773                 goto out;
774
775         mutex_lock(&bcm->mutex);
776         spin_lock_irqsave(&bcm->irq_lock, flags);
777         err = -ENODEV;
778         if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED)
779                 err = bcm43xx_sprom_read(bcm, sprom);
780         spin_unlock_irqrestore(&bcm->irq_lock, flags);
781         mutex_unlock(&bcm->mutex);
782         if (!err)
783                 data->data.length = sprom2hex(sprom, extra);
784         kfree(sprom);
785 out:
786         return err;
787 }
788
789 static int bcm43xx_wx_sprom_write(struct net_device *net_dev,
790                                   struct iw_request_info *info,
791                                   union iwreq_data *data,
792                                   char *extra)
793 {
794         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
795         int err = -EPERM;
796         u16 *sprom;
797         unsigned long flags;
798         char *input;
799         unsigned int len;
800
801         if (!capable(CAP_SYS_RAWIO))
802                 goto out;
803
804         err = -ENOMEM;
805         sprom = kmalloc(BCM43xx_SPROM_SIZE * sizeof(*sprom),
806                         GFP_KERNEL);
807         if (!sprom)
808                 goto out;
809
810         len = data->data.length;
811         extra[len - 1] = '\0';
812         input = strchr(extra, ':');
813         if (input) {
814                 input++;
815                 len -= input - extra;
816         } else
817                 input = extra;
818         err = hex2sprom(sprom, input, len);
819         if (err)
820                 goto out_kfree;
821
822         mutex_lock(&bcm->mutex);
823         spin_lock_irqsave(&bcm->irq_lock, flags);
824         spin_lock(&bcm->leds_lock);
825         err = -ENODEV;
826         if (bcm43xx_status(bcm) == BCM43xx_STAT_INITIALIZED)
827                 err = bcm43xx_sprom_write(bcm, sprom);
828         spin_unlock(&bcm->leds_lock);
829         spin_unlock_irqrestore(&bcm->irq_lock, flags);
830         mutex_unlock(&bcm->mutex);
831 out_kfree:
832         kfree(sprom);
833 out:
834         return err;
835 }
836
837 /* Get wireless statistics.  Called by /proc/net/wireless and by SIOCGIWSTATS */
838
839 static struct iw_statistics *bcm43xx_get_wireless_stats(struct net_device *net_dev)
840 {
841         struct bcm43xx_private *bcm = bcm43xx_priv(net_dev);
842         struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
843         struct iw_statistics *wstats;
844         struct ieee80211_network *network = NULL;
845         static int tmp_level = 0;
846         static int tmp_qual = 0;
847         unsigned long flags;
848
849         wstats = &bcm->stats.wstats;
850         if (!mac->associated) {
851                 wstats->miss.beacon = 0;
852 //              bcm->ieee->ieee_stats.tx_retry_limit_exceeded = 0; // FIXME: should this be cleared here?
853                 wstats->discard.retries = 0;
854 //              bcm->ieee->ieee_stats.tx_discards_wrong_sa = 0; // FIXME: same question
855                 wstats->discard.nwid = 0;
856 //              bcm->ieee->ieee_stats.rx_discards_undecryptable = 0; // FIXME: ditto
857                 wstats->discard.code = 0;
858 //              bcm->ieee->ieee_stats.rx_fragments = 0;  // FIXME: same here
859                 wstats->discard.fragment = 0;
860                 wstats->discard.misc = 0;
861                 wstats->qual.qual = 0;
862                 wstats->qual.level = 0;
863                 wstats->qual.noise = 0;
864                 wstats->qual.updated = 7;
865                 wstats->qual.updated |= IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
866                 return wstats;
867         }
868         /* fill in the real statistics when iface associated */
869         spin_lock_irqsave(&mac->ieee->lock, flags);
870         list_for_each_entry(network, &mac->ieee->network_list, list) {
871                 if (!memcmp(mac->associnfo.bssid, network->bssid, ETH_ALEN)) {
872                         if (!tmp_level) {       /* get initial values */
873                                 tmp_level = network->stats.signal;
874                                 tmp_qual = network->stats.rssi;
875                         } else {                /* smooth results */
876                                 tmp_level = (15 * tmp_level + network->stats.signal)/16;
877                                 tmp_qual = (15 * tmp_qual + network->stats.rssi)/16;
878                         }
879                         break;
880                 }
881         }
882         spin_unlock_irqrestore(&mac->ieee->lock, flags);
883         wstats->qual.level = tmp_level;
884         wstats->qual.qual = 100 * tmp_qual / RX_RSSI_MAX;
885         wstats->qual.noise = bcm->stats.noise;
886         wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
887         wstats->discard.code = bcm->ieee->ieee_stats.rx_discards_undecryptable;
888         wstats->discard.retries = bcm->ieee->ieee_stats.tx_retry_limit_exceeded;
889         wstats->discard.nwid = bcm->ieee->ieee_stats.tx_discards_wrong_sa;
890         wstats->discard.fragment = bcm->ieee->ieee_stats.rx_fragments;
891         wstats->discard.misc = 0;       // FIXME
892         wstats->miss.beacon = 0;        // FIXME
893         return wstats;
894 }
895
896
897 #ifdef WX
898 # undef WX
899 #endif
900 #define WX(ioctl)  [(ioctl) - SIOCSIWCOMMIT]
901 static const iw_handler bcm43xx_wx_handlers[] = {
902         /* Wireless Identification */
903         WX(SIOCGIWNAME)         = bcm43xx_wx_get_name,
904         /* Basic operations */
905         WX(SIOCSIWFREQ)         = bcm43xx_wx_set_channelfreq,
906         WX(SIOCGIWFREQ)         = bcm43xx_wx_get_channelfreq,
907         WX(SIOCSIWMODE)         = bcm43xx_wx_set_mode,
908         WX(SIOCGIWMODE)         = bcm43xx_wx_get_mode,
909         /* Informative stuff */
910         WX(SIOCGIWRANGE)        = bcm43xx_wx_get_rangeparams,
911         /* Access Point manipulation */
912         WX(SIOCSIWAP)           = ieee80211softmac_wx_set_wap,
913         WX(SIOCGIWAP)           = ieee80211softmac_wx_get_wap,
914         WX(SIOCSIWSCAN)         = ieee80211softmac_wx_trigger_scan,
915         WX(SIOCGIWSCAN)         = ieee80211softmac_wx_get_scan_results,
916         /* 802.11 specific support */
917         WX(SIOCSIWESSID)        = ieee80211softmac_wx_set_essid,
918         WX(SIOCGIWESSID)        = ieee80211softmac_wx_get_essid,
919         WX(SIOCSIWNICKN)        = bcm43xx_wx_set_nick,
920         WX(SIOCGIWNICKN)        = bcm43xx_wx_get_nick,
921         /* Other parameters */
922         WX(SIOCSIWRATE)         = ieee80211softmac_wx_set_rate,
923         WX(SIOCGIWRATE)         = ieee80211softmac_wx_get_rate,
924         WX(SIOCSIWRTS)          = bcm43xx_wx_set_rts,
925         WX(SIOCGIWRTS)          = bcm43xx_wx_get_rts,
926         WX(SIOCSIWFRAG)         = bcm43xx_wx_set_frag,
927         WX(SIOCGIWFRAG)         = bcm43xx_wx_get_frag,
928         WX(SIOCSIWTXPOW)        = bcm43xx_wx_set_xmitpower,
929         WX(SIOCGIWTXPOW)        = bcm43xx_wx_get_xmitpower,
930 //TODO  WX(SIOCSIWRETRY)        = bcm43xx_wx_set_retry,
931 //TODO  WX(SIOCGIWRETRY)        = bcm43xx_wx_get_retry,
932         /* Encoding */
933         WX(SIOCSIWENCODE)       = bcm43xx_wx_set_encoding,
934         WX(SIOCGIWENCODE)       = bcm43xx_wx_get_encoding,
935         WX(SIOCSIWENCODEEXT)    = bcm43xx_wx_set_encodingext,
936         WX(SIOCGIWENCODEEXT)    = bcm43xx_wx_get_encodingext,
937         /* Power saving */
938 //TODO  WX(SIOCSIWPOWER)        = bcm43xx_wx_set_power,
939 //TODO  WX(SIOCGIWPOWER)        = bcm43xx_wx_get_power,
940         WX(SIOCSIWGENIE)        = ieee80211softmac_wx_set_genie,
941         WX(SIOCGIWGENIE)        = ieee80211softmac_wx_get_genie,
942         WX(SIOCSIWAUTH)         = ieee80211_wx_set_auth,
943         WX(SIOCGIWAUTH)         = ieee80211_wx_get_auth,
944 };
945 #undef WX
946
947 static const iw_handler bcm43xx_priv_wx_handlers[] = {
948         /* Set Interference Mitigation Mode. */
949         bcm43xx_wx_set_interfmode,
950         /* Get Interference Mitigation Mode. */
951         bcm43xx_wx_get_interfmode,
952         /* Enable/Disable Short Preamble mode. */
953         bcm43xx_wx_set_shortpreamble,
954         /* Get Short Preamble mode. */
955         bcm43xx_wx_get_shortpreamble,
956         /* Enable/Disable Software Encryption mode */
957         bcm43xx_wx_set_swencryption,
958         /* Get Software Encryption mode */
959         bcm43xx_wx_get_swencryption,
960         /* Write SRPROM data. */
961         bcm43xx_wx_sprom_write,
962         /* Read SPROM data. */
963         bcm43xx_wx_sprom_read,
964 };
965
966 #define PRIV_WX_SET_INTERFMODE          (SIOCIWFIRSTPRIV + 0)
967 #define PRIV_WX_GET_INTERFMODE          (SIOCIWFIRSTPRIV + 1)
968 #define PRIV_WX_SET_SHORTPREAMBLE       (SIOCIWFIRSTPRIV + 2)
969 #define PRIV_WX_GET_SHORTPREAMBLE       (SIOCIWFIRSTPRIV + 3)
970 #define PRIV_WX_SET_SWENCRYPTION        (SIOCIWFIRSTPRIV + 4)
971 #define PRIV_WX_GET_SWENCRYPTION        (SIOCIWFIRSTPRIV + 5)
972 #define PRIV_WX_SPROM_WRITE             (SIOCIWFIRSTPRIV + 6)
973 #define PRIV_WX_SPROM_READ              (SIOCIWFIRSTPRIV + 7)
974
975 #define PRIV_WX_DUMMY(ioctl)    \
976         {                                       \
977                 .cmd            = (ioctl),      \
978                 .name           = "__unused"    \
979         }
980
981 static const struct iw_priv_args bcm43xx_priv_wx_args[] = {
982         {
983                 .cmd            = PRIV_WX_SET_INTERFMODE,
984                 .set_args       = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
985                 .name           = "set_interfmode",
986         },
987         {
988                 .cmd            = PRIV_WX_GET_INTERFMODE,
989                 .get_args       = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
990                 .name           = "get_interfmode",
991         },
992         {
993                 .cmd            = PRIV_WX_SET_SHORTPREAMBLE,
994                 .set_args       = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
995                 .name           = "set_shortpreamb",
996         },
997         {
998                 .cmd            = PRIV_WX_GET_SHORTPREAMBLE,
999                 .get_args       = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
1000                 .name           = "get_shortpreamb",
1001         },
1002         {
1003                 .cmd            = PRIV_WX_SET_SWENCRYPTION,
1004                 .set_args       = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1005                 .name           = "set_swencrypt",
1006         },
1007         {
1008                 .cmd            = PRIV_WX_GET_SWENCRYPTION,
1009                 .get_args       = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
1010                 .name           = "get_swencrypt",
1011         },
1012         {
1013                 .cmd            = PRIV_WX_SPROM_WRITE,
1014                 .set_args       = IW_PRIV_TYPE_CHAR | SPROM_BUFFERSIZE,
1015                 .name           = "write_sprom",
1016         },
1017         {
1018                 .cmd            = PRIV_WX_SPROM_READ,
1019                 .get_args       = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | SPROM_BUFFERSIZE,
1020                 .name           = "read_sprom",
1021         },
1022 };
1023
1024 const struct iw_handler_def bcm43xx_wx_handlers_def = {
1025         .standard               = bcm43xx_wx_handlers,
1026         .num_standard           = ARRAY_SIZE(bcm43xx_wx_handlers),
1027         .num_private            = ARRAY_SIZE(bcm43xx_priv_wx_handlers),
1028         .num_private_args       = ARRAY_SIZE(bcm43xx_priv_wx_args),
1029         .private                = bcm43xx_priv_wx_handlers,
1030         .private_args           = bcm43xx_priv_wx_args,
1031         .get_wireless_stats     = bcm43xx_get_wireless_stats,
1032 };