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