drivers/net/wireless/libertas/wext.c

   1 /**
   2   * This file contains ioctl functions
   3   */
   4 #include <linux/ctype.h>
   5 #include <linux/delay.h>
   6 #include <linux/if.h>
   7 #include <linux/if_arp.h>
   8 #include <linux/wireless.h>
   9 #include <linux/bitops.h>
  10
  11 #include <net/ieee80211.h>
  12 #include <net/iw_handler.h>
  13
  14 #include "host.h"
  15 #include "radiotap.h"
  16 #include "decl.h"
  17 #include "defs.h"
  18 #include "dev.h"
  19 #include "join.h"
  20 #include "wext.h"
  21 #include "assoc.h"
  22
  23
  24 /**
  25  *  @brief Convert mw value to dbm value
  26  *
  27  *  @param mw      the value of mw
  28  *  @return        the value of dbm
  29  */
  30 static int mw_to_dbm(int mw)
  31 {
  32         if (mw < 2)
  33                 return 0;
  34         else if (mw < 3)
  35                 return 3;
  36         else if (mw < 4)
  37                 return 5;
  38         else if (mw < 6)
  39                 return 7;
  40         else if (mw < 7)
  41                 return 8;
  42         else if (mw < 8)
  43                 return 9;
  44         else if (mw < 10)
  45                 return 10;
  46         else if (mw < 13)
  47                 return 11;
  48         else if (mw < 16)
  49                 return 12;
  50         else if (mw < 20)
  51                 return 13;
  52         else if (mw < 25)
  53                 return 14;
  54         else if (mw < 32)
  55                 return 15;
  56         else if (mw < 40)
  57                 return 16;
  58         else if (mw < 50)
  59                 return 17;
  60         else if (mw < 63)
  61                 return 18;
  62         else if (mw < 79)
  63                 return 19;
  64         else if (mw < 100)
  65                 return 20;
  66         else
  67                 return 21;
  68 }
  69
  70 /**
  71  *  @brief Find the channel frequency power info with specific channel
  72  *
  73  *  @param adapter      A pointer to wlan_adapter structure
  74  *  @param band         it can be BAND_A, BAND_G or BAND_B
  75  *  @param channel      the channel for looking
  76  *  @return             A pointer to struct chan_freq_power structure or NULL if not find.
  77  */
  78 struct chan_freq_power *libertas_find_cfp_by_band_and_channel(wlan_adapter * adapter,
  79                                                  u8 band, u16 channel)
  80 {
  81         struct chan_freq_power *cfp = NULL;
  82         struct region_channel *rc;
  83         int count = sizeof(adapter->region_channel) /
  84             sizeof(adapter->region_channel[0]);
  85         int i, j;
  86
  87         for (j = 0; !cfp && (j < count); j++) {
  88                 rc = &adapter->region_channel[j];
  89
  90                 if (adapter->enable11d)
  91                         rc = &adapter->universal_channel[j];
  92                 if (!rc->valid || !rc->CFP)
  93                         continue;
  94                 if (rc->band != band)
  95                         continue;
  96                 for (i = 0; i < rc->nrcfp; i++) {
  97                         if (rc->CFP[i].channel == channel) {
  98                                 cfp = &rc->CFP[i];
  99                                 break;
 100                         }
 101                 }
 102         }
 103
 104         if (!cfp && channel)
 105                 lbs_pr_debug(1, "libertas_find_cfp_by_band_and_channel(): cannot find "
 106                        "cfp by band %d & channel %d\n", band, channel);
 107
 108         return cfp;
 109 }
 110
 111 /**
 112  *  @brief Find the channel frequency power info with specific frequency
 113  *
 114  *  @param adapter      A pointer to wlan_adapter structure
 115  *  @param band         it can be BAND_A, BAND_G or BAND_B
 116  *  @param freq         the frequency for looking
 117  *  @return             A pointer to struct chan_freq_power structure or NULL if not find.
 118  */
 119 static struct chan_freq_power *find_cfp_by_band_and_freq(wlan_adapter * adapter,
 120                                                      u8 band, u32 freq)
 121 {
 122         struct chan_freq_power *cfp = NULL;
 123         struct region_channel *rc;
 124         int count = sizeof(adapter->region_channel) /
 125             sizeof(adapter->region_channel[0]);
 126         int i, j;
 127
 128         for (j = 0; !cfp && (j < count); j++) {
 129                 rc = &adapter->region_channel[j];
 130
 131                 if (adapter->enable11d)
 132                         rc = &adapter->universal_channel[j];
 133                 if (!rc->valid || !rc->CFP)
 134                         continue;
 135                 if (rc->band != band)
 136                         continue;
 137                 for (i = 0; i < rc->nrcfp; i++) {
 138                         if (rc->CFP[i].freq == freq) {
 139                                 cfp = &rc->CFP[i];
 140                                 break;
 141                         }
 142                 }
 143         }
 144
 145         if (!cfp && freq)
 146                 lbs_pr_debug(1, "find_cfp_by_band_and_freql(): cannot find cfp by "
 147                        "band %d & freq %d\n", band, freq);
 148
 149         return cfp;
 150 }
 151
 152 static int updatecurrentchannel(wlan_private * priv)
 153 {
 154         int ret;
 155
 156         /*
 157          ** the channel in f/w could be out of sync, get the current channel
 158          */
 159         ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,
 160                                     cmd_opt_802_11_rf_channel_get,
 161                                     cmd_option_waitforrsp, 0, NULL);
 162
 163         lbs_pr_debug(1, "Current channel = %d\n",
 164                priv->adapter->curbssparams.channel);
 165
 166         return ret;
 167 }
 168
 169 static int setcurrentchannel(wlan_private * priv, int channel)
 170 {
 171         lbs_pr_debug(1, "Set channel = %d\n", channel);
 172
 173         /*
 174          **  Current channel is not set to adhocchannel requested, set channel
 175          */
 176         return (libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,
 177                                       cmd_opt_802_11_rf_channel_set,
 178                                       cmd_option_waitforrsp, 0, &channel));
 179 }
 180
 181 static int changeadhocchannel(wlan_private * priv, int channel)
 182 {
 183         int ret = 0;
 184         wlan_adapter *adapter = priv->adapter;
 185
 186         adapter->adhocchannel = channel;
 187
 188         updatecurrentchannel(priv);
 189
 190         if (adapter->curbssparams.channel == adapter->adhocchannel) {
 191                 /* adhocchannel is set to the current channel already */
 192                 LEAVE();
 193                 return 0;
 194         }
 195
 196         lbs_pr_debug(1, "Updating channel from %d to %d\n",
 197                adapter->curbssparams.channel, adapter->adhocchannel);
 198
 199         setcurrentchannel(priv, adapter->adhocchannel);
 200
 201         updatecurrentchannel(priv);
 202
 203         if (adapter->curbssparams.channel != adapter->adhocchannel) {
 204                 lbs_pr_debug(1, "failed to updated channel to %d, channel = %d\n",
 205                        adapter->adhocchannel, adapter->curbssparams.channel);
 206                 LEAVE();
 207                 return -1;
 208         }
 209
 210         if (adapter->connect_status == libertas_connected) {
 211                 int i;
 212                 struct WLAN_802_11_SSID curadhocssid;
 213
 214                 lbs_pr_debug(1, "channel Changed while in an IBSS\n");
 215
 216                 /* Copy the current ssid */
 217                 memcpy(&curadhocssid, &adapter->curbssparams.ssid,
 218                        sizeof(struct WLAN_802_11_SSID));
 219
 220                 /* Exit Adhoc mode */
 221                 lbs_pr_debug(1, "In changeadhocchannel(): Sending Adhoc Stop\n");
 222                 ret = libertas_stop_adhoc_network(priv);
 223
 224                 if (ret) {
 225                         LEAVE();
 226                         return ret;
 227                 }
 228                 /* Scan for the network, do not save previous results.  Stale
 229                  *   scan data will cause us to join a non-existant adhoc network
 230                  */
 231                 libertas_send_specific_SSID_scan(priv, &curadhocssid, 0);
 232
 233                 // find out the BSSID that matches the current SSID
 234                 i = libertas_find_SSID_in_list(adapter, &curadhocssid, NULL,
 235                                    IW_MODE_ADHOC);
 236
 237                 if (i >= 0) {
 238                         lbs_pr_debug(1, "SSID found at %d in List,"
 239                                "so join\n", i);
 240                         libertas_join_adhoc_network(priv, &adapter->scantable[i]);
 241                 } else {
 242                         // else send START command
 243                         lbs_pr_debug(1, "SSID not found in list, "
 244                                "so creating adhoc with ssid = %s\n",
 245                                curadhocssid.ssid);
 246                         libertas_start_adhoc_network(priv, &curadhocssid);
 247                 }               // end of else (START command)
 248         }
 249
 250         LEAVE();
 251         return 0;
 252 }
 253
 254 /**
 255  *  @brief Set Radio On/OFF
 256  *
 257  *  @param priv                 A pointer to wlan_private structure
 258  *  @option                     Radio Option
 259  *  @return                     0 --success, otherwise fail
 260  */
 261 int wlan_radio_ioctl(wlan_private * priv, u8 option)
 262 {
 263         int ret = 0;
 264         wlan_adapter *adapter = priv->adapter;
 265
 266         ENTER();
 267
 268         if (adapter->radioon != option) {
 269                 lbs_pr_debug(1, "Switching %s the Radio\n", option ? "On" : "Off");
 270                 adapter->radioon = option;
 271
 272                 ret = libertas_prepare_and_send_command(priv,
 273                                             cmd_802_11_radio_control,
 274                                             cmd_act_set,
 275                                             cmd_option_waitforrsp, 0, NULL);
 276         }
 277
 278         LEAVE();
 279         return ret;
 280 }
 281
 282 /**
 283  *  @brief Copy rates
 284  *
 285  *  @param dest                 A pointer to Dest Buf
 286  *  @param src                  A pointer to Src Buf
 287  *  @param len                  The len of Src Buf
 288  *  @return                     Number of rates copyed
 289  */
 290 static inline int copyrates(u8 * dest, int pos, u8 * src, int len)
 291 {
 292         int i;
 293
 294         for (i = 0; i < len && src[i]; i++, pos++) {
 295                 if (pos >= sizeof(u8) * WLAN_SUPPORTED_RATES)
 296                         break;
 297                 dest[pos] = src[i];
 298         }
 299
 300         return pos;
 301 }
 302
 303 /**
 304  *  @brief Get active data rates
 305  *
 306  *  @param adapter              A pointer to wlan_adapter structure
 307  *  @param rate                 The buf to return the active rates
 308  *  @return                     The number of rates
 309  */
 310 static int get_active_data_rates(wlan_adapter * adapter,
 311                                  u8* rates)
 312 {
 313         int k = 0;
 314
 315         ENTER();
 316
 317         if (adapter->connect_status != libertas_connected) {
 318                 if (adapter->mode == IW_MODE_INFRA) {
 319                         lbs_pr_debug(1, "Infra\n");
 320                         k = copyrates(rates, k, libertas_supported_rates,
 321                                       sizeof(libertas_supported_rates));
 322                 } else {
 323                         lbs_pr_debug(1, "Adhoc G\n");
 324                         k = copyrates(rates, k, libertas_adhoc_rates_g,
 325                                       sizeof(libertas_adhoc_rates_g));
 326                 }
 327         } else {
 328                 k = copyrates(rates, 0, adapter->curbssparams.datarates,
 329                               adapter->curbssparams.numofrates);
 330         }
 331
 332         LEAVE();
 333
 334         return k;
 335 }
 336
 337 static int wlan_get_name(struct net_device *dev, struct iw_request_info *info,
 338                          char *cwrq, char *extra)
 339 {
 340         const char *cp;
 341         char comm[6] = { "COMM-" };
 342         char mrvl[6] = { "MRVL-" };
 343         int cnt;
 344
 345         ENTER();
 346
 347         strcpy(cwrq, mrvl);
 348
 349         cp = strstr(libertas_driver_version, comm);
 350         if (cp == libertas_driver_version)      //skip leading "COMM-"
 351                 cp = libertas_driver_version + strlen(comm);
 352         else
 353                 cp = libertas_driver_version;
 354
 355         cnt = strlen(mrvl);
 356         cwrq += cnt;
 357         while (cnt < 16 && (*cp != '-')) {
 358                 *cwrq++ = toupper(*cp++);
 359                 cnt++;
 360         }
 361         *cwrq = '\0';
 362
 363         LEAVE();
 364
 365         return 0;
 366 }
 367
 368 static int wlan_get_freq(struct net_device *dev, struct iw_request_info *info,
 369                          struct iw_freq *fwrq, char *extra)
 370 {
 371         wlan_private *priv = dev->priv;
 372         wlan_adapter *adapter = priv->adapter;
 373         struct chan_freq_power *cfp;
 374
 375         ENTER();
 376
 377         cfp = libertas_find_cfp_by_band_and_channel(adapter, 0,
 378                                            adapter->curbssparams.channel);
 379
 380         if (!cfp) {
 381                 if (adapter->curbssparams.channel)
 382                         lbs_pr_debug(1, "Invalid channel=%d\n",
 383                                adapter->curbssparams.channel);
 384                 return -EINVAL;
 385         }
 386
 387         fwrq->m = (long)cfp->freq * 100000;
 388         fwrq->e = 1;
 389
 390         lbs_pr_debug(1, "freq=%u\n", fwrq->m);
 391
 392         LEAVE();
 393         return 0;
 394 }
 395
 396 static int wlan_get_wap(struct net_device *dev, struct iw_request_info *info,
 397                         struct sockaddr *awrq, char *extra)
 398 {
 399         wlan_private *priv = dev->priv;
 400         wlan_adapter *adapter = priv->adapter;
 401
 402         ENTER();
 403
 404         if (adapter->connect_status == libertas_connected) {
 405                 memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN);
 406         } else {
 407                 memset(awrq->sa_data, 0, ETH_ALEN);
 408         }
 409         awrq->sa_family = ARPHRD_ETHER;
 410
 411         LEAVE();
 412         return 0;
 413 }
 414
 415 static int wlan_set_nick(struct net_device *dev, struct iw_request_info *info,
 416                          struct iw_point *dwrq, char *extra)
 417 {
 418         wlan_private *priv = dev->priv;
 419         wlan_adapter *adapter = priv->adapter;
 420
 421         ENTER();
 422
 423         /*
 424          * Check the size of the string
 425          */
 426
 427         if (dwrq->length > 16) {
 428                 return -E2BIG;
 429         }
 430
 431         mutex_lock(&adapter->lock);
 432         memset(adapter->nodename, 0, sizeof(adapter->nodename));
 433         memcpy(adapter->nodename, extra, dwrq->length);
 434         mutex_unlock(&adapter->lock);
 435
 436         LEAVE();
 437         return 0;
 438 }
 439
 440 static int wlan_get_nick(struct net_device *dev, struct iw_request_info *info,
 441                          struct iw_point *dwrq, char *extra)
 442 {
 443         wlan_private *priv = dev->priv;
 444         wlan_adapter *adapter = priv->adapter;
 445
 446         ENTER();
 447
 448         /*
 449          * Get the Nick Name saved
 450          */
 451
 452         mutex_lock(&adapter->lock);
 453         strncpy(extra, adapter->nodename, 16);
 454         mutex_unlock(&adapter->lock);
 455
 456         extra[16] = '\0';
 457
 458         /*
 459          * If none, we may want to get the one that was set
 460          */
 461
 462         /*
 463          * Push it out !
 464          */
 465         dwrq->length = strlen(extra) + 1;
 466
 467         LEAVE();
 468         return 0;
 469 }
 470
 471 static int wlan_set_rts(struct net_device *dev, struct iw_request_info *info,
 472                         struct iw_param *vwrq, char *extra)
 473 {
 474         int ret = 0;
 475         wlan_private *priv = dev->priv;
 476         wlan_adapter *adapter = priv->adapter;
 477         int rthr = vwrq->value;
 478
 479         ENTER();
 480
 481         if (vwrq->disabled) {
 482                 adapter->rtsthsd = rthr = MRVDRV_RTS_MAX_VALUE;
 483         } else {
 484                 if (rthr < MRVDRV_RTS_MIN_VALUE || rthr > MRVDRV_RTS_MAX_VALUE)
 485                         return -EINVAL;
 486                 adapter->rtsthsd = rthr;
 487         }
 488
 489         ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
 490                                     cmd_act_set, cmd_option_waitforrsp,
 491                                     OID_802_11_RTS_THRESHOLD, &rthr);
 492
 493         LEAVE();
 494         return ret;
 495 }
 496
 497 static int wlan_get_rts(struct net_device *dev, struct iw_request_info *info,
 498                         struct iw_param *vwrq, char *extra)
 499 {
 500         int ret = 0;
 501         wlan_private *priv = dev->priv;
 502         wlan_adapter *adapter = priv->adapter;
 503
 504         ENTER();
 505
 506         adapter->rtsthsd = 0;
 507         ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
 508                                     cmd_act_get, cmd_option_waitforrsp,
 509                                     OID_802_11_RTS_THRESHOLD, NULL);
 510         if (ret) {
 511                 LEAVE();
 512                 return ret;
 513         }
 514
 515         vwrq->value = adapter->rtsthsd;
 516         vwrq->disabled = ((vwrq->value < MRVDRV_RTS_MIN_VALUE)
 517                           || (vwrq->value > MRVDRV_RTS_MAX_VALUE));
 518         vwrq->fixed = 1;
 519
 520         LEAVE();
 521         return 0;
 522 }
 523
 524 static int wlan_set_frag(struct net_device *dev, struct iw_request_info *info,
 525                          struct iw_param *vwrq, char *extra)
 526 {
 527         int ret = 0;
 528         int fthr = vwrq->value;
 529         wlan_private *priv = dev->priv;
 530         wlan_adapter *adapter = priv->adapter;
 531
 532         ENTER();
 533
 534         if (vwrq->disabled) {
 535                 adapter->fragthsd = fthr = MRVDRV_FRAG_MAX_VALUE;
 536         } else {
 537                 if (fthr < MRVDRV_FRAG_MIN_VALUE
 538                     || fthr > MRVDRV_FRAG_MAX_VALUE)
 539                         return -EINVAL;
 540                 adapter->fragthsd = fthr;
 541         }
 542
 543         ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
 544                                     cmd_act_set, cmd_option_waitforrsp,
 545                                     OID_802_11_FRAGMENTATION_THRESHOLD, &fthr);
 546         LEAVE();
 547         return ret;
 548 }
 549
 550 static int wlan_get_frag(struct net_device *dev, struct iw_request_info *info,
 551                          struct iw_param *vwrq, char *extra)
 552 {
 553         int ret = 0;
 554         wlan_private *priv = dev->priv;
 555         wlan_adapter *adapter = priv->adapter;
 556
 557         ENTER();
 558
 559         adapter->fragthsd = 0;
 560         ret = libertas_prepare_and_send_command(priv,
 561                                     cmd_802_11_snmp_mib,
 562                                     cmd_act_get, cmd_option_waitforrsp,
 563                                     OID_802_11_FRAGMENTATION_THRESHOLD, NULL);
 564         if (ret) {
 565                 LEAVE();
 566                 return ret;
 567         }
 568
 569         vwrq->value = adapter->fragthsd;
 570         vwrq->disabled = ((vwrq->value < MRVDRV_FRAG_MIN_VALUE)
 571                           || (vwrq->value > MRVDRV_FRAG_MAX_VALUE));
 572         vwrq->fixed = 1;
 573
 574         LEAVE();
 575         return ret;
 576 }
 577
 578 static int wlan_get_mode(struct net_device *dev,
 579                          struct iw_request_info *info, u32 * uwrq, char *extra)
 580 {
 581         wlan_private *priv = dev->priv;
 582         wlan_adapter *adapter = priv->adapter;
 583
 584         ENTER();
 585
 586         *uwrq = adapter->mode;
 587
 588         LEAVE();
 589         return 0;
 590 }
 591
 592 static int wlan_get_txpow(struct net_device *dev,
 593                           struct iw_request_info *info,
 594                           struct iw_param *vwrq, char *extra)
 595 {
 596         int ret = 0;
 597         wlan_private *priv = dev->priv;
 598         wlan_adapter *adapter = priv->adapter;
 599
 600         ENTER();
 601
 602         ret = libertas_prepare_and_send_command(priv,
 603                                     cmd_802_11_rf_tx_power,
 604                                     cmd_act_tx_power_opt_get,
 605                                     cmd_option_waitforrsp, 0, NULL);
 606
 607         if (ret) {
 608                 LEAVE();
 609                 return ret;
 610         }
 611
 612         lbs_pr_debug(1, "TXPOWER GET %d dbm.\n", adapter->txpowerlevel);
 613         vwrq->value = adapter->txpowerlevel;
 614         vwrq->fixed = 1;
 615         if (adapter->radioon) {
 616                 vwrq->disabled = 0;
 617                 vwrq->flags = IW_TXPOW_DBM;
 618         } else {
 619                 vwrq->disabled = 1;
 620         }
 621
 622         LEAVE();
 623         return 0;
 624 }
 625
 626 static int wlan_set_retry(struct net_device *dev, struct iw_request_info *info,
 627                           struct iw_param *vwrq, char *extra)
 628 {
 629         int ret = 0;
 630         wlan_private *priv = dev->priv;
 631         wlan_adapter *adapter = priv->adapter;
 632
 633         ENTER();
 634
 635         if (vwrq->flags == IW_RETRY_LIMIT) {
 636                 /* The MAC has a 4-bit Total_Tx_Count register
 637                    Total_Tx_Count = 1 + Tx_Retry_Count */
 638 #define TX_RETRY_MIN 0
 639 #define TX_RETRY_MAX 14
 640                 if (vwrq->value < TX_RETRY_MIN || vwrq->value > TX_RETRY_MAX)
 641                         return -EINVAL;
 642
 643                 /* Adding 1 to convert retry count to try count */
 644                 adapter->txretrycount = vwrq->value + 1;
 645
 646                 ret = libertas_prepare_and_send_command(priv, cmd_802_11_snmp_mib,
 647                                             cmd_act_set,
 648                                             cmd_option_waitforrsp,
 649                                             OID_802_11_TX_RETRYCOUNT, NULL);
 650
 651                 if (ret) {
 652                         LEAVE();
 653                         return ret;
 654                 }
 655         } else {
 656                 return -EOPNOTSUPP;
 657         }
 658
 659         LEAVE();
 660         return 0;
 661 }
 662
 663 static int wlan_get_retry(struct net_device *dev, struct iw_request_info *info,
 664                           struct iw_param *vwrq, char *extra)
 665 {
 666         wlan_private *priv = dev->priv;
 667         wlan_adapter *adapter = priv->adapter;
 668         int ret = 0;
 669
 670         ENTER();
 671         adapter->txretrycount = 0;
 672         ret = libertas_prepare_and_send_command(priv,
 673                                     cmd_802_11_snmp_mib,
 674                                     cmd_act_get, cmd_option_waitforrsp,
 675                                     OID_802_11_TX_RETRYCOUNT, NULL);
 676         if (ret) {
 677                 LEAVE();
 678                 return ret;
 679         }
 680         vwrq->disabled = 0;
 681         if (!vwrq->flags) {
 682                 vwrq->flags = IW_RETRY_LIMIT;
 683                 /* Subtract 1 to convert try count to retry count */
 684                 vwrq->value = adapter->txretrycount - 1;
 685         }
 686
 687         LEAVE();
 688         return 0;
 689 }
 690
 691 static inline void sort_channels(struct iw_freq *freq, int num)
 692 {
 693         int i, j;
 694         struct iw_freq temp;
 695
 696         for (i = 0; i < num; i++)
 697                 for (j = i + 1; j < num; j++)
 698                         if (freq[i].i > freq[j].i) {
 699                                 temp.i = freq[i].i;
 700                                 temp.m = freq[i].m;
 701
 702                                 freq[i].i = freq[j].i;
 703                                 freq[i].m = freq[j].m;
 704
 705                                 freq[j].i = temp.i;
 706                                 freq[j].m = temp.m;
 707                         }
 708 }
 709
 710 /* data rate listing
 711         MULTI_BANDS:
 712                 abg             a       b       b/g
 713    Infra        G(12)           A(8)    B(4)    G(12)
 714    Adhoc        A+B(12)         A(8)    B(4)    B(4)
 715
 716         non-MULTI_BANDS:
 717                                         b       b/g
 718    Infra                                B(4)    G(12)
 719    Adhoc                                B(4)    B(4)
 720  */
 721 /**
 722  *  @brief Get Range Info
 723  *
 724  *  @param dev                  A pointer to net_device structure
 725  *  @param info                 A pointer to iw_request_info structure
 726  *  @param vwrq                 A pointer to iw_param structure
 727  *  @param extra                A pointer to extra data buf
 728  *  @return                     0 --success, otherwise fail
 729  */
 730 static int wlan_get_range(struct net_device *dev, struct iw_request_info *info,
 731                           struct iw_point *dwrq, char *extra)
 732 {
 733         int i, j;
 734         wlan_private *priv = dev->priv;
 735         wlan_adapter *adapter = priv->adapter;
 736         struct iw_range *range = (struct iw_range *)extra;
 737         struct chan_freq_power *cfp;
 738         u8 rates[WLAN_SUPPORTED_RATES];
 739
 740         u8 flag = 0;
 741
 742         ENTER();
 743
 744         dwrq->length = sizeof(struct iw_range);
 745         memset(range, 0, sizeof(struct iw_range));
 746
 747         range->min_nwid = 0;
 748         range->max_nwid = 0;
 749
 750         memset(rates, 0, sizeof(rates));
 751         range->num_bitrates = get_active_data_rates(adapter, rates);
 752
 753         for (i = 0; i < min_t(__u8, range->num_bitrates, IW_MAX_BITRATES) && rates[i];
 754              i++) {
 755                 range->bitrate[i] = (rates[i] & 0x7f) * 500000;
 756         }
 757         range->num_bitrates = i;
 758         lbs_pr_debug(1, "IW_MAX_BITRATES=%d num_bitrates=%d\n", IW_MAX_BITRATES,
 759                range->num_bitrates);
 760
 761         range->num_frequency = 0;
 762         if (priv->adapter->enable11d &&
 763             adapter->connect_status == libertas_connected) {
 764                 u8 chan_no;
 765                 u8 band;
 766
 767                 struct parsed_region_chan_11d *parsed_region_chan =
 768                     &adapter->parsed_region_chan;
 769
 770                 if (parsed_region_chan == NULL) {
 771                         lbs_pr_debug(1, "11D:parsed_region_chan is NULL\n");
 772                         LEAVE();
 773                         return 0;
 774                 }
 775                 band = parsed_region_chan->band;
 776                 lbs_pr_debug(1, "band=%d NoOfChan=%d\n", band,
 777                        parsed_region_chan->nr_chan);
 778
 779                 for (i = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
 780                      && (i < parsed_region_chan->nr_chan); i++) {
 781                         chan_no = parsed_region_chan->chanpwr[i].chan;
 782                         lbs_pr_debug(1, "chan_no=%d\n", chan_no);
 783                         range->freq[range->num_frequency].i = (long)chan_no;
 784                         range->freq[range->num_frequency].m =
 785                             (long)libertas_chan_2_freq(chan_no, band) * 100000;
 786                         range->freq[range->num_frequency].e = 1;
 787                         range->num_frequency++;
 788                 }
 789                 flag = 1;
 790         }
 791         if (!flag) {
 792                 for (j = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
 793                      && (j < sizeof(adapter->region_channel)
 794                          / sizeof(adapter->region_channel[0])); j++) {
 795                         cfp = adapter->region_channel[j].CFP;
 796                         for (i = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
 797                              && adapter->region_channel[j].valid
 798                              && cfp
 799                              && (i < adapter->region_channel[j].nrcfp); i++) {
 800                                 range->freq[range->num_frequency].i =
 801                                     (long)cfp->channel;
 802                                 range->freq[range->num_frequency].m =
 803                                     (long)cfp->freq * 100000;
 804                                 range->freq[range->num_frequency].e = 1;
 805                                 cfp++;
 806                                 range->num_frequency++;
 807                         }
 808                 }
 809         }
 810
 811         lbs_pr_debug(1, "IW_MAX_FREQUENCIES=%d num_frequency=%d\n",
 812                IW_MAX_FREQUENCIES, range->num_frequency);
 813
 814         range->num_channels = range->num_frequency;
 815
 816         sort_channels(&range->freq[0], range->num_frequency);
 817
 818         /*
 819          * Set an indication of the max TCP throughput in bit/s that we can
 820          * expect using this interface
 821          */
 822         if (i > 2)
 823                 range->throughput = 5000 * 1000;
 824         else
 825                 range->throughput = 1500 * 1000;
 826
 827         range->min_rts = MRVDRV_RTS_MIN_VALUE;
 828         range->max_rts = MRVDRV_RTS_MAX_VALUE;
 829         range->min_frag = MRVDRV_FRAG_MIN_VALUE;
 830         range->max_frag = MRVDRV_FRAG_MAX_VALUE;
 831
 832         range->encoding_size[0] = 5;
 833         range->encoding_size[1] = 13;
 834         range->num_encoding_sizes = 2;
 835         range->max_encoding_tokens = 4;
 836
 837         range->min_pmp = 1000000;
 838         range->max_pmp = 120000000;
 839         range->min_pmt = 1000;
 840         range->max_pmt = 1000000;
 841         range->pmp_flags = IW_POWER_PERIOD;
 842         range->pmt_flags = IW_POWER_TIMEOUT;
 843         range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
 844
 845         /*
 846          * Minimum version we recommend
 847          */
 848         range->we_version_source = 15;
 849
 850         /*
 851          * Version we are compiled with
 852          */
 853         range->we_version_compiled = WIRELESS_EXT;
 854
 855         range->retry_capa = IW_RETRY_LIMIT;
 856         range->retry_flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
 857
 858         range->min_retry = TX_RETRY_MIN;
 859         range->max_retry = TX_RETRY_MAX;
 860
 861         /*
 862          * Set the qual, level and noise range values
 863          */
 864         range->max_qual.qual = 100;
 865         range->max_qual.level = 0;
 866         range->max_qual.noise = 0;
 867         range->max_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 868
 869         range->avg_qual.qual = 70;
 870         /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
 871         range->avg_qual.level = 0;
 872         range->avg_qual.noise = 0;
 873         range->avg_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 874
 875         range->sensitivity = 0;
 876
 877         /*
 878          * Setup the supported power level ranges
 879          */
 880         memset(range->txpower, 0, sizeof(range->txpower));
 881         range->txpower[0] = 5;
 882         range->txpower[1] = 7;
 883         range->txpower[2] = 9;
 884         range->txpower[3] = 11;
 885         range->txpower[4] = 13;
 886         range->txpower[5] = 15;
 887         range->txpower[6] = 17;
 888         range->txpower[7] = 19;
 889
 890         range->num_txpower = 8;
 891         range->txpower_capa = IW_TXPOW_DBM;
 892         range->txpower_capa |= IW_TXPOW_RANGE;
 893
 894         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
 895                                 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
 896                                 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
 897         range->event_capa[1] = IW_EVENT_CAPA_K_1;
 898
 899         if (adapter->fwcapinfo & FW_CAPINFO_WPA) {
 900                 range->enc_capa =   IW_ENC_CAPA_WPA
 901                                   | IW_ENC_CAPA_WPA2
 902                                   | IW_ENC_CAPA_CIPHER_TKIP
 903                                   | IW_ENC_CAPA_CIPHER_CCMP;
 904         }
 905
 906         LEAVE();
 907         return 0;
 908 }
 909
 910 static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
 911                           struct iw_param *vwrq, char *extra)
 912 {
 913         wlan_private *priv = dev->priv;
 914         wlan_adapter *adapter = priv->adapter;
 915
 916         ENTER();
 917
 918         /* PS is currently supported only in Infrastructure mode
 919          * Remove this check if it is to be supported in IBSS mode also
 920          */
 921
 922         if (vwrq->disabled) {
 923                 adapter->psmode = wlan802_11powermodecam;
 924                 if (adapter->psstate != PS_STATE_FULL_POWER) {
 925                         libertas_ps_wakeup(priv, cmd_option_waitforrsp);
 926                 }
 927
 928                 return 0;
 929         }
 930
 931         if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
 932                 lbs_pr_debug(1,
 933                        "Setting power timeout command is not supported\n");
 934                 return -EINVAL;
 935         } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
 936                 lbs_pr_debug(1, "Setting power period command is not supported\n");
 937                 return -EINVAL;
 938         }
 939
 940         if (adapter->psmode != wlan802_11powermodecam) {
 941                 return 0;
 942         }
 943
 944         adapter->psmode = wlan802_11powermodemax_psp;
 945
 946         if (adapter->connect_status == libertas_connected) {
 947                 libertas_ps_sleep(priv, cmd_option_waitforrsp);
 948         }
 949
 950         LEAVE();
 951         return 0;
 952 }
 953
 954 static int wlan_get_power(struct net_device *dev, struct iw_request_info *info,
 955                           struct iw_param *vwrq, char *extra)
 956 {
 957         wlan_private *priv = dev->priv;
 958         wlan_adapter *adapter = priv->adapter;
 959         int mode;
 960
 961         ENTER();
 962
 963         mode = adapter->psmode;
 964
 965         if ((vwrq->disabled = (mode == wlan802_11powermodecam))
 966             || adapter->connect_status == libertas_disconnected) {
 967                 LEAVE();
 968                 return 0;
 969         }
 970
 971         vwrq->value = 0;
 972
 973         LEAVE();
 974         return 0;
 975 }
 976
 977 /*
 978  * iwpriv settable callbacks
 979  */
 980
 981 static const iw_handler wlan_private_handler[] = {
 982         NULL,                   /* SIOCIWFIRSTPRIV */
 983 };
 984
 985 static const struct iw_priv_args wlan_private_args[] = {
 986         /*
 987          * { cmd, set_args, get_args, name }
 988          */
 989         {
 990          WLANSCAN_TYPE,
 991          IW_PRIV_TYPE_CHAR | 8,
 992          IW_PRIV_TYPE_CHAR | 8,
 993          "scantype"},
 994
 995         {
 996          WLAN_SETINT_GETINT,
 997          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 998          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 999          ""},
1000         {
1001          WLANNF,
1002          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1003          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1004          "getNF"},
1005         {
1006          WLANRSSI,
1007          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1008          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1009          "getRSSI"},
1010         {
1011          WLANENABLE11D,
1012          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1013          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1014          "enable11d"},
1015         {
1016          WLANADHOCGRATE,
1017          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1018          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1019          "adhocgrate"},
1020
1021         {
1022          WLAN_SUBCMD_SET_PRESCAN,
1023          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1024          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1025          "prescan"},
1026         {
1027          WLAN_SETONEINT_GETONEINT,
1028          IW_PRIV_TYPE_INT | 1,
1029          IW_PRIV_TYPE_INT | 1,
1030          ""},
1031         {
1032          WLAN_BEACON_INTERVAL,
1033          IW_PRIV_TYPE_INT | 1,
1034          IW_PRIV_TYPE_INT | 1,
1035          "bcninterval"},
1036         {
1037          WLAN_LISTENINTRVL,
1038          IW_PRIV_TYPE_INT | 1,
1039          IW_PRIV_TYPE_INT | 1,
1040          "lolisteninter"},
1041         {
1042          WLAN_TXCONTROL,
1043          IW_PRIV_TYPE_INT | 1,
1044          IW_PRIV_TYPE_INT | 1,
1045          "txcontrol"},
1046         {
1047          WLAN_NULLPKTINTERVAL,
1048          IW_PRIV_TYPE_INT | 1,
1049          IW_PRIV_TYPE_INT | 1,
1050          "psnullinterval"},
1051         /* Using iwpriv sub-command feature */
1052         {
1053          WLAN_SETONEINT_GETNONE,        /* IOCTL: 24 */
1054          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1055          IW_PRIV_TYPE_NONE,
1056          ""},
1057
1058         {
1059          WLAN_SUBCMD_SETRXANTENNA,
1060          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1061          IW_PRIV_TYPE_NONE,
1062          "setrxant"},
1063         {
1064          WLAN_SUBCMD_SETTXANTENNA,
1065          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1066          IW_PRIV_TYPE_NONE,
1067          "settxant"},
1068         {
1069          WLANSETENCRYPTIONMODE,
1070          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1071          IW_PRIV_TYPE_NONE,
1072          "encryptionmode",
1073          },
1074         {
1075          WLANSETREGION,
1076          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1077          IW_PRIV_TYPE_NONE,
1078          "setregioncode"},
1079         {
1080          WLAN_SET_LISTEN_INTERVAL,
1081          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1082          IW_PRIV_TYPE_NONE,
1083          "setlisteninter"},
1084         {
1085          WLAN_SET_MULTIPLE_DTIM,
1086          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1087          IW_PRIV_TYPE_NONE,
1088          "setmultipledtim"},
1089         {
1090          WLAN_SET_ATIM_WINDOW,
1091          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1092          IW_PRIV_TYPE_NONE,
1093          "atimwindow"},
1094         {
1095          WLANSETBCNAVG,
1096          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1097          IW_PRIV_TYPE_NONE,
1098          "setbcnavg"},
1099         {
1100          WLANSETDATAAVG,
1101          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1102          IW_PRIV_TYPE_NONE,
1103          "setdataavg"},
1104         {
1105          WLAN_SET_LINKMODE,
1106          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1107          IW_PRIV_TYPE_NONE,
1108          "linkmode"},
1109         {
1110          WLAN_SET_RADIOMODE,
1111          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1112          IW_PRIV_TYPE_NONE,
1113          "radiomode"},
1114         {
1115          WLAN_SET_DEBUGMODE,
1116          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1117          IW_PRIV_TYPE_NONE,
1118          "debugmode"},
1119         {
1120          WLAN_SUBCMD_MESH_SET_TTL,
1121          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1122          IW_PRIV_TYPE_NONE,
1123          "mesh_set_ttl"},
1124         {
1125          WLAN_SETNONE_GETONEINT,
1126          IW_PRIV_TYPE_NONE,
1127          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1128          ""},
1129         {
1130          WLANGETREGION,
1131          IW_PRIV_TYPE_NONE,
1132          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1133          "getregioncode"},
1134         {
1135          WLAN_GET_LISTEN_INTERVAL,
1136          IW_PRIV_TYPE_NONE,
1137          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1138          "getlisteninter"},
1139         {
1140          WLAN_GET_MULTIPLE_DTIM,
1141          IW_PRIV_TYPE_NONE,
1142          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1143          "getmultipledtim"},
1144         {
1145          WLAN_GET_TX_RATE,
1146          IW_PRIV_TYPE_NONE,
1147          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1148          "gettxrate"},
1149         {
1150          WLANGETBCNAVG,
1151          IW_PRIV_TYPE_NONE,
1152          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1153          "getbcnavg"},
1154         {
1155          WLAN_GET_LINKMODE,
1156          IW_PRIV_TYPE_NONE,
1157          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1158          "get_linkmode"},
1159         {
1160          WLAN_GET_RADIOMODE,
1161          IW_PRIV_TYPE_NONE,
1162          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1163          "get_radiomode"},
1164         {
1165          WLAN_GET_DEBUGMODE,
1166          IW_PRIV_TYPE_NONE,
1167          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1168          "get_debugmode"},
1169         {
1170          WLAN_SUBCMD_FWT_CLEANUP,
1171          IW_PRIV_TYPE_NONE,
1172          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1173          "fwt_cleanup"},
1174         {
1175          WLAN_SUBCMD_FWT_TIME,
1176          IW_PRIV_TYPE_NONE,
1177          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1178          "fwt_time"},
1179         {
1180          WLAN_SUBCMD_MESH_GET_TTL,
1181          IW_PRIV_TYPE_NONE,
1182          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1183          "mesh_get_ttl"},
1184         {
1185          WLAN_SETNONE_GETTWELVE_CHAR,
1186          IW_PRIV_TYPE_NONE,
1187          IW_PRIV_TYPE_CHAR | 12,
1188          ""},
1189         {
1190          WLAN_SUBCMD_GETRXANTENNA,
1191          IW_PRIV_TYPE_NONE,
1192          IW_PRIV_TYPE_CHAR | 12,
1193          "getrxant"},
1194         {
1195          WLAN_SUBCMD_GETTXANTENNA,
1196          IW_PRIV_TYPE_NONE,
1197          IW_PRIV_TYPE_CHAR | 12,
1198          "gettxant"},
1199         {
1200          WLAN_GET_TSF,
1201          IW_PRIV_TYPE_NONE,
1202          IW_PRIV_TYPE_CHAR | 12,
1203          "gettsf"},
1204         {
1205          WLAN_SETNONE_GETNONE,
1206          IW_PRIV_TYPE_NONE,
1207          IW_PRIV_TYPE_NONE,
1208          ""},
1209         {
1210          WLANDEAUTH,
1211          IW_PRIV_TYPE_NONE,
1212          IW_PRIV_TYPE_NONE,
1213          "deauth"},
1214         {
1215          WLANADHOCSTOP,
1216          IW_PRIV_TYPE_NONE,
1217          IW_PRIV_TYPE_NONE,
1218          "adhocstop"},
1219         {
1220          WLANRADIOON,
1221          IW_PRIV_TYPE_NONE,
1222          IW_PRIV_TYPE_NONE,
1223          "radioon"},
1224         {
1225          WLANRADIOOFF,
1226          IW_PRIV_TYPE_NONE,
1227          IW_PRIV_TYPE_NONE,
1228          "radiooff"},
1229         {
1230          WLANWLANIDLEON,
1231          IW_PRIV_TYPE_NONE,
1232          IW_PRIV_TYPE_NONE,
1233          "wlanidle-on"},
1234         {
1235          WLANWLANIDLEOFF,
1236          IW_PRIV_TYPE_NONE,
1237          IW_PRIV_TYPE_NONE,
1238          "wlanidle-off"},
1239         {
1240          WLAN_SUBCMD_FWT_RESET,
1241          IW_PRIV_TYPE_NONE,
1242          IW_PRIV_TYPE_NONE,
1243          "fwt_reset"},
1244         {
1245          WLAN_SUBCMD_BT_RESET,
1246          IW_PRIV_TYPE_NONE,
1247          IW_PRIV_TYPE_NONE,
1248          "bt_reset"},
1249         {
1250          WLAN_SET128CHAR_GET128CHAR,
1251          IW_PRIV_TYPE_CHAR | 128,
1252          IW_PRIV_TYPE_CHAR | 128,
1253          ""},
1254         /* BT Management */
1255         {
1256          WLAN_SUBCMD_BT_ADD,
1257          IW_PRIV_TYPE_CHAR | 128,
1258          IW_PRIV_TYPE_CHAR | 128,
1259          "bt_add"},
1260         {
1261          WLAN_SUBCMD_BT_DEL,
1262          IW_PRIV_TYPE_CHAR | 128,
1263          IW_PRIV_TYPE_CHAR | 128,
1264          "bt_del"},
1265         {
1266          WLAN_SUBCMD_BT_LIST,
1267          IW_PRIV_TYPE_CHAR | 128,
1268          IW_PRIV_TYPE_CHAR | 128,
1269          "bt_list"},
1270         /* FWT Management */
1271         {
1272          WLAN_SUBCMD_FWT_ADD,
1273          IW_PRIV_TYPE_CHAR | 128,
1274          IW_PRIV_TYPE_CHAR | 128,
1275          "fwt_add"},
1276         {
1277          WLAN_SUBCMD_FWT_DEL,
1278          IW_PRIV_TYPE_CHAR | 128,
1279          IW_PRIV_TYPE_CHAR | 128,
1280          "fwt_del"},
1281         {
1282          WLAN_SUBCMD_FWT_LOOKUP,
1283          IW_PRIV_TYPE_CHAR | 128,
1284          IW_PRIV_TYPE_CHAR | 128,
1285          "fwt_lookup"},
1286         {
1287          WLAN_SUBCMD_FWT_LIST_NEIGHBOR,
1288          IW_PRIV_TYPE_CHAR | 128,
1289          IW_PRIV_TYPE_CHAR | 128,
1290          "fwt_list_neigh"},
1291         {
1292          WLAN_SUBCMD_FWT_LIST,
1293          IW_PRIV_TYPE_CHAR | 128,
1294          IW_PRIV_TYPE_CHAR | 128,
1295          "fwt_list"},
1296         {
1297          WLAN_SUBCMD_FWT_LIST_ROUTE,
1298          IW_PRIV_TYPE_CHAR | 128,
1299          IW_PRIV_TYPE_CHAR | 128,
1300          "fwt_list_route"},
1301         {
1302          WLANSCAN_MODE,
1303          IW_PRIV_TYPE_CHAR | 128,
1304          IW_PRIV_TYPE_CHAR | 128,
1305          "scanmode"},
1306         {
1307          WLAN_GET_ADHOC_STATUS,
1308          IW_PRIV_TYPE_CHAR | 128,
1309          IW_PRIV_TYPE_CHAR | 128,
1310          "getadhocstatus"},
1311         {
1312          WLAN_SETNONE_GETWORDCHAR,
1313          IW_PRIV_TYPE_NONE,
1314          IW_PRIV_TYPE_CHAR | 128,
1315          ""},
1316         {
1317          WLANGETLOG,
1318          IW_PRIV_TYPE_NONE,
1319          IW_PRIV_TYPE_CHAR | GETLOG_BUFSIZE,
1320          "getlog"},
1321         {
1322          WLAN_SET_GET_SIXTEEN_INT,
1323          IW_PRIV_TYPE_INT | 16,
1324          IW_PRIV_TYPE_INT | 16,
1325          ""},
1326         {
1327          WLAN_TPCCFG,
1328          IW_PRIV_TYPE_INT | 16,
1329          IW_PRIV_TYPE_INT | 16,
1330          "tpccfg"},
1331         {
1332          WLAN_POWERCFG,
1333          IW_PRIV_TYPE_INT | 16,
1334          IW_PRIV_TYPE_INT | 16,
1335          "powercfg"},
1336         {
1337          WLAN_AUTO_FREQ_SET,
1338          IW_PRIV_TYPE_INT | 16,
1339          IW_PRIV_TYPE_INT | 16,
1340          "setafc"},
1341         {
1342          WLAN_AUTO_FREQ_GET,
1343          IW_PRIV_TYPE_INT | 16,
1344          IW_PRIV_TYPE_INT | 16,
1345          "getafc"},
1346         {
1347          WLAN_SCANPROBES,
1348          IW_PRIV_TYPE_INT | 16,
1349          IW_PRIV_TYPE_INT | 16,
1350          "scanprobes"},
1351         {
1352          WLAN_LED_GPIO_CTRL,
1353          IW_PRIV_TYPE_INT | 16,
1354          IW_PRIV_TYPE_INT | 16,
1355          "ledgpio"},
1356         {
1357          WLAN_ADAPT_RATESET,
1358          IW_PRIV_TYPE_INT | 16,
1359          IW_PRIV_TYPE_INT | 16,
1360          "rateadapt"},
1361         {
1362          WLAN_INACTIVITY_TIMEOUT,
1363          IW_PRIV_TYPE_INT | 16,
1364          IW_PRIV_TYPE_INT | 16,
1365          "inactivityto"},
1366         {
1367          WLANSNR,
1368          IW_PRIV_TYPE_INT | 16,
1369          IW_PRIV_TYPE_INT | 16,
1370          "getSNR"},
1371         {
1372          WLAN_GET_RATE,
1373          IW_PRIV_TYPE_INT | 16,
1374          IW_PRIV_TYPE_INT | 16,
1375          "getrate"},
1376         {
1377          WLAN_GET_RXINFO,
1378          IW_PRIV_TYPE_INT | 16,
1379          IW_PRIV_TYPE_INT | 16,
1380          "getrxinfo"},
1381 };
1382
1383 static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
1384 {
1385         enum {
1386                 POOR = 30,
1387                 FAIR = 60,
1388                 GOOD = 80,
1389                 VERY_GOOD = 90,
1390                 EXCELLENT = 95,
1391                 PERFECT = 100
1392         };
1393         wlan_private *priv = dev->priv;
1394         wlan_adapter *adapter = priv->adapter;
1395         u32 rssi_qual;
1396         u32 tx_qual;
1397         u32 quality = 0;
1398         int stats_valid = 0;
1399         u8 rssi;
1400         u32 tx_retries;
1401
1402         ENTER();
1403
1404         priv->wstats.status = adapter->mode;
1405
1406         /* If we're not associated, all quality values are meaningless */
1407         if (adapter->connect_status != libertas_connected)
1408                 goto out;
1409
1410         /* Quality by RSSI */
1411         priv->wstats.qual.level =
1412             CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
1413              adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
1414
1415         if (adapter->NF[TYPE_BEACON][TYPE_NOAVG] == 0) {
1416                 priv->wstats.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE;
1417         } else {
1418                 priv->wstats.qual.noise =
1419                     CAL_NF(adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
1420         }
1421
1422         lbs_pr_debug(1, "Signal Level = %#x\n", priv->wstats.qual.level);
1423         lbs_pr_debug(1, "Noise = %#x\n", priv->wstats.qual.noise);
1424
1425         rssi = priv->wstats.qual.level - priv->wstats.qual.noise;
1426         if (rssi < 15)
1427                 rssi_qual = rssi * POOR / 10;
1428         else if (rssi < 20)
1429                 rssi_qual = (rssi - 15) * (FAIR - POOR) / 5 + POOR;
1430         else if (rssi < 30)
1431                 rssi_qual = (rssi - 20) * (GOOD - FAIR) / 5 + FAIR;
1432         else if (rssi < 40)
1433                 rssi_qual = (rssi - 30) * (VERY_GOOD - GOOD) /
1434                     10 + GOOD;
1435         else
1436                 rssi_qual = (rssi - 40) * (PERFECT - VERY_GOOD) /
1437                     10 + VERY_GOOD;
1438         quality = rssi_qual;
1439
1440         /* Quality by TX errors */
1441         priv->wstats.discard.retries = priv->stats.tx_errors;
1442
1443         tx_retries = adapter->logmsg.retry;
1444
1445         if (tx_retries > 75)
1446                 tx_qual = (90 - tx_retries) * POOR / 15;
1447         else if (tx_retries > 70)
1448                 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
1449         else if (tx_retries > 65)
1450                 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
1451         else if (tx_retries > 50)
1452                 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
1453                     15 + GOOD;
1454         else
1455                 tx_qual = (50 - tx_retries) *
1456                     (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
1457         quality = min(quality, tx_qual);
1458
1459         priv->wstats.discard.code = adapter->logmsg.wepundecryptable;
1460         priv->wstats.discard.fragment = adapter->logmsg.fcserror;
1461         priv->wstats.discard.retries = tx_retries;
1462         priv->wstats.discard.misc = adapter->logmsg.ackfailure;
1463
1464         /* Calculate quality */
1465         priv->wstats.qual.qual = max(quality, (u32)100);
1466         priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1467         stats_valid = 1;
1468
1469         /* update stats asynchronously for future calls */
1470         libertas_prepare_and_send_command(priv, cmd_802_11_rssi, 0,
1471                                         0, 0, NULL);
1472         libertas_prepare_and_send_command(priv, cmd_802_11_get_log, 0,
1473                                         0, 0, NULL);
1474 out:
1475         if (!stats_valid) {
1476                 priv->wstats.miss.beacon = 0;
1477                 priv->wstats.discard.retries = 0;
1478                 priv->wstats.qual.qual = 0;
1479                 priv->wstats.qual.level = 0;
1480                 priv->wstats.qual.noise = 0;
1481                 priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED;
1482                 priv->wstats.qual.updated |= IW_QUAL_NOISE_INVALID |
1483                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
1484         }
1485
1486         LEAVE ();
1487         return &priv->wstats;
1488
1489
1490 }
1491
1492 static int wlan_set_freq(struct net_device *dev, struct iw_request_info *info,
1493                   struct iw_freq *fwrq, char *extra)
1494 {
1495         int ret = 0;
1496         wlan_private *priv = dev->priv;
1497         wlan_adapter *adapter = priv->adapter;
1498         int rc = -EINPROGRESS;  /* Call commit handler */
1499         struct chan_freq_power *cfp;
1500
1501         ENTER();
1502
1503         /*
1504          * If setting by frequency, convert to a channel
1505          */
1506         if (fwrq->e == 1) {
1507
1508                 long f = fwrq->m / 100000;
1509                 int c = 0;
1510
1511                 cfp = find_cfp_by_band_and_freq(adapter, 0, f);
1512                 if (!cfp) {
1513                         lbs_pr_debug(1, "Invalid freq=%ld\n", f);
1514                         return -EINVAL;
1515                 }
1516
1517                 c = (int)cfp->channel;
1518
1519                 if (c < 0)
1520                         return -EINVAL;
1521
1522                 fwrq->e = 0;
1523                 fwrq->m = c;
1524         }
1525
1526         /*
1527          * Setting by channel number
1528          */
1529         if (fwrq->m > 1000 || fwrq->e > 0) {
1530                 rc = -EOPNOTSUPP;
1531         } else {
1532                 int channel = fwrq->m;
1533
1534                 cfp = libertas_find_cfp_by_band_and_channel(adapter, 0, channel);
1535                 if (!cfp) {
1536                         rc = -EINVAL;
1537                 } else {
1538                         if (adapter->mode == IW_MODE_ADHOC) {
1539                                 rc = changeadhocchannel(priv, channel);
1540                                 /*  If station is WEP enabled, send the
1541                                  *  command to set WEP in firmware
1542                                  */
1543                                 if (adapter->secinfo.wep_enabled) {
1544                                         lbs_pr_debug(1, "set_freq: WEP enabled\n");
1545                                         ret = libertas_prepare_and_send_command(priv,
1546                                                                     cmd_802_11_set_wep,
1547                                                                     cmd_act_add,
1548                                                                     cmd_option_waitforrsp,
1549                                                                     0,
1550                                                                     NULL);
1551
1552                                         if (ret) {
1553                                                 LEAVE();
1554                                                 return ret;
1555                                         }
1556
1557                                         adapter->currentpacketfilter |=
1558                                             cmd_act_mac_wep_enable;
1559
1560                                         libertas_set_mac_packet_filter(priv);
1561                                 }
1562                         } else {
1563                                 rc = -EOPNOTSUPP;
1564                         }
1565                 }
1566         }
1567
1568         LEAVE();
1569         return rc;
1570 }
1571
1572 /**
1573  *  @brief use index to get the data rate
1574  *
1575  *  @param index                The index of data rate
1576  *  @return                     data rate or 0
1577  */
1578 u32 libertas_index_to_data_rate(u8 index)
1579 {
1580         if (index >= sizeof(libertas_wlan_data_rates))
1581                 index = 0;
1582
1583         return libertas_wlan_data_rates[index];
1584 }
1585
1586 /**
1587  *  @brief use rate to get the index
1588  *
1589  *  @param rate                 data rate
1590  *  @return                     index or 0
1591  */
1592 u8 libertas_data_rate_to_index(u32 rate)
1593 {
1594         u8 *ptr;
1595
1596         if (rate)
1597                 if ((ptr = memchr(libertas_wlan_data_rates, (u8) rate,
1598                                   sizeof(libertas_wlan_data_rates))))
1599                         return (ptr - libertas_wlan_data_rates);
1600
1601         return 0;
1602 }
1603
1604 static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
1605                   struct iw_param *vwrq, char *extra)
1606 {
1607         wlan_private *priv = dev->priv;
1608         wlan_adapter *adapter = priv->adapter;
1609         u32 data_rate;
1610         u16 action;
1611         int ret = 0;
1612         u8 rates[WLAN_SUPPORTED_RATES];
1613         u8 *rate;
1614
1615         ENTER();
1616
1617         lbs_pr_debug(1, "Vwrq->value = %d\n", vwrq->value);
1618
1619         if (vwrq->value == -1) {
1620                 action = cmd_act_set_tx_auto;   // Auto
1621                 adapter->is_datarate_auto = 1;
1622                 adapter->datarate = 0;
1623         } else {
1624                 if (vwrq->value % 100000) {
1625                         return -EINVAL;
1626                 }
1627
1628                 data_rate = vwrq->value / 500000;
1629
1630                 memset(rates, 0, sizeof(rates));
1631                 get_active_data_rates(adapter, rates);
1632                 rate = rates;
1633                 while (*rate) {
1634                         lbs_pr_debug(1, "Rate=0x%X  Wanted=0x%X\n", *rate,
1635                                data_rate);
1636                         if ((*rate & 0x7f) == (data_rate & 0x7f))
1637                                 break;
1638                         rate++;
1639                 }
1640                 if (!*rate) {
1641                         lbs_pr_alert( "The fixed data rate 0x%X is out "
1642                                "of range.\n", data_rate);
1643                         return -EINVAL;
1644                 }
1645
1646                 adapter->datarate = data_rate;
1647                 action = cmd_act_set_tx_fix_rate;
1648                 adapter->is_datarate_auto = 0;
1649         }
1650
1651         ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
1652                                     action, cmd_option_waitforrsp, 0, NULL);
1653
1654         LEAVE();
1655         return ret;
1656 }
1657
1658 static int wlan_get_rate(struct net_device *dev, struct iw_request_info *info,
1659                   struct iw_param *vwrq, char *extra)
1660 {
1661         wlan_private *priv = dev->priv;
1662         wlan_adapter *adapter = priv->adapter;
1663
1664         ENTER();
1665
1666         if (adapter->is_datarate_auto) {
1667                 vwrq->fixed = 0;
1668         } else {
1669                 vwrq->fixed = 1;
1670         }
1671
1672         vwrq->value = adapter->datarate * 500000;
1673
1674         LEAVE();
1675         return 0;
1676 }
1677
1678 static int wlan_set_mode(struct net_device *dev,
1679                   struct iw_request_info *info, u32 * uwrq, char *extra)
1680 {
1681         int ret = 0;
1682         wlan_private *priv = dev->priv;
1683         wlan_adapter *adapter = priv->adapter;
1684         struct assoc_request * assoc_req;
1685
1686         ENTER();
1687
1688         if (   (*uwrq != IW_MODE_ADHOC)
1689             && (*uwrq != IW_MODE_INFRA)
1690             && (*uwrq != IW_MODE_AUTO)) {
1691                 lbs_pr_debug(1, "Invalid mode: 0x%x\n", *uwrq);
1692                 ret = -EINVAL;
1693                 goto out;
1694         }
1695
1696         mutex_lock(&adapter->lock);
1697         assoc_req = wlan_get_association_request(adapter);
1698         if (!assoc_req) {
1699                 ret = -ENOMEM;
1700                 wlan_cancel_association_work(priv);
1701         } else {
1702                 assoc_req->mode = *uwrq;
1703                 set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
1704                 wlan_postpone_association_work(priv);
1705                 lbs_pr_debug(1, "Switching to mode: 0x%x\n", *uwrq);
1706         }
1707         mutex_unlock(&adapter->lock);
1708
1709 out:
1710         LEAVE();
1711         return ret;
1712 }
1713
1714
1715 /**
1716  *  @brief Get Encryption key
1717  *
1718  *  @param dev                  A pointer to net_device structure
1719  *  @param info                 A pointer to iw_request_info structure
1720  *  @param vwrq                 A pointer to iw_param structure
1721  *  @param extra                A pointer to extra data buf
1722  *  @return                     0 --success, otherwise fail
1723  */
1724 static int wlan_get_encode(struct net_device *dev,
1725                            struct iw_request_info *info,
1726                            struct iw_point *dwrq, u8 * extra)
1727 {
1728         wlan_private *priv = dev->priv;
1729         wlan_adapter *adapter = priv->adapter;
1730         int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1731
1732         ENTER();
1733
1734         lbs_pr_debug(1, "flags=0x%x index=%d length=%d wep_tx_keyidx=%d\n",
1735                dwrq->flags, index, dwrq->length, adapter->wep_tx_keyidx);
1736
1737         dwrq->flags = 0;
1738
1739         /* Authentication method */
1740         switch (adapter->secinfo.auth_mode) {
1741         case IW_AUTH_ALG_OPEN_SYSTEM:
1742                 dwrq->flags = IW_ENCODE_OPEN;
1743                 break;
1744
1745         case IW_AUTH_ALG_SHARED_KEY:
1746         case IW_AUTH_ALG_LEAP:
1747                 dwrq->flags = IW_ENCODE_RESTRICTED;
1748                 break;
1749         default:
1750                 dwrq->flags = IW_ENCODE_DISABLED | IW_ENCODE_OPEN;
1751                 break;
1752         }
1753
1754         if (   adapter->secinfo.wep_enabled
1755             || adapter->secinfo.WPAenabled
1756             || adapter->secinfo.WPA2enabled) {
1757                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1758         } else {
1759                 dwrq->flags |= IW_ENCODE_DISABLED;
1760         }
1761
1762         memset(extra, 0, 16);
1763
1764         mutex_lock(&adapter->lock);
1765
1766         /* Default to returning current transmit key */
1767         if (index < 0)
1768                 index = adapter->wep_tx_keyidx;
1769
1770         if ((adapter->wep_keys[index].len) && adapter->secinfo.wep_enabled) {
1771                 memcpy(extra, adapter->wep_keys[index].key,
1772                        adapter->wep_keys[index].len);
1773                 dwrq->length = adapter->wep_keys[index].len;
1774
1775                 dwrq->flags |= (index + 1);
1776                 /* Return WEP enabled */
1777                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1778         } else if ((adapter->secinfo.WPAenabled)
1779                    || (adapter->secinfo.WPA2enabled)) {
1780                 /* return WPA enabled */
1781                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1782         } else {
1783                 dwrq->flags |= IW_ENCODE_DISABLED;
1784         }
1785
1786         mutex_unlock(&adapter->lock);
1787
1788         dwrq->flags |= IW_ENCODE_NOKEY;
1789
1790         lbs_pr_debug(1, "key:%02x:%02x:%02x:%02x:%02x:%02x keylen=%d\n",
1791                extra[0], extra[1], extra[2],
1792                extra[3], extra[4], extra[5], dwrq->length);
1793
1794         lbs_pr_debug(1, "Return flags=0x%x\n", dwrq->flags);
1795
1796         LEAVE();
1797         return 0;
1798 }
1799
1800 /**
1801  *  @brief Set Encryption key (internal)
1802  *
1803  *  @param priv                 A pointer to private card structure
1804  *  @param key_material         A pointer to key material
1805  *  @param key_length           length of key material
1806  *  @param index                key index to set
1807  *  @param set_tx_key           Force set TX key (1 = yes, 0 = no)
1808  *  @return                     0 --success, otherwise fail
1809  */
1810 static int wlan_set_wep_key(struct assoc_request *assoc_req,
1811                             const char *key_material,
1812                             u16 key_length,
1813                             u16 index,
1814                             int set_tx_key)
1815 {
1816         struct WLAN_802_11_KEY *pkey;
1817
1818         ENTER();
1819
1820         /* Paranoid validation of key index */
1821         if (index > 3) {
1822                 LEAVE();
1823                 return -EINVAL;
1824         }
1825
1826         /* validate max key length */
1827         if (key_length > KEY_LEN_WEP_104) {
1828                 LEAVE();
1829                 return -EINVAL;
1830         }
1831
1832         pkey = &assoc_req->wep_keys[index];
1833
1834         if (key_length > 0) {
1835                 memset(pkey, 0, sizeof(struct WLAN_802_11_KEY));
1836                 pkey->type = KEY_TYPE_ID_WEP;
1837
1838                 /* Standardize the key length */
1839                 pkey->len = (key_length > KEY_LEN_WEP_40) ?
1840                                 KEY_LEN_WEP_104 : KEY_LEN_WEP_40;
1841                 memcpy(pkey->key, key_material, key_length);
1842         }
1843
1844         if (set_tx_key) {
1845                 /* Ensure the chosen key is valid */
1846                 if (!pkey->len) {
1847                         lbs_pr_debug(1, "key not set, so cannot enable it\n");
1848                         LEAVE();
1849                         return -EINVAL;
1850                 }
1851                 assoc_req->wep_tx_keyidx = index;
1852         }
1853
1854         assoc_req->secinfo.wep_enabled = 1;
1855
1856         LEAVE();
1857         return 0;
1858 }
1859
1860 static int validate_key_index(u16 def_index, u16 raw_index,
1861                               u16 *out_index, u16 *is_default)
1862 {
1863         if (!out_index || !is_default)
1864                 return -EINVAL;
1865
1866         /* Verify index if present, otherwise use default TX key index */
1867         if (raw_index > 0) {
1868                 if (raw_index > 4)
1869                         return -EINVAL;
1870                 *out_index = raw_index - 1;
1871         } else {
1872                 *out_index = def_index;
1873                 *is_default = 1;
1874         }
1875         return 0;
1876 }
1877
1878 static void disable_wep(struct assoc_request *assoc_req)
1879 {
1880         int i;
1881
1882         /* Set Open System auth mode */
1883         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1884
1885         /* Clear WEP keys and mark WEP as disabled */
1886         assoc_req->secinfo.wep_enabled = 0;
1887         for (i = 0; i < 4; i++)
1888                 assoc_req->wep_keys[i].len = 0;
1889
1890         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1891         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1892 }
1893
1894 /**
1895  *  @brief Set Encryption key
1896  *
1897  *  @param dev                  A pointer to net_device structure
1898  *  @param info                 A pointer to iw_request_info structure
1899  *  @param vwrq                 A pointer to iw_param structure
1900  *  @param extra                A pointer to extra data buf
1901  *  @return                     0 --success, otherwise fail
1902  */
1903 static int wlan_set_encode(struct net_device *dev,
1904                     struct iw_request_info *info,
1905                     struct iw_point *dwrq, char *extra)
1906 {
1907         int ret = 0;
1908         wlan_private *priv = dev->priv;
1909         wlan_adapter *adapter = priv->adapter;
1910         struct assoc_request * assoc_req;
1911         u16 is_default = 0, index = 0, set_tx_key = 0;
1912
1913         ENTER();
1914
1915         mutex_lock(&adapter->lock);
1916         assoc_req = wlan_get_association_request(adapter);
1917         if (!assoc_req) {
1918                 ret = -ENOMEM;
1919                 goto out;
1920         }
1921
1922         if (dwrq->flags & IW_ENCODE_DISABLED) {
1923                 disable_wep (assoc_req);
1924                 goto out;
1925         }
1926
1927         ret = validate_key_index(assoc_req->wep_tx_keyidx,
1928                                  (dwrq->flags & IW_ENCODE_INDEX),
1929                                  &index, &is_default);
1930         if (ret) {
1931                 ret = -EINVAL;
1932                 goto out;
1933         }
1934
1935         /* If WEP isn't enabled, or if there is no key data but a valid
1936          * index, set the TX key.
1937          */
1938         if (!assoc_req->secinfo.wep_enabled || (dwrq->length == 0 && !is_default))
1939                 set_tx_key = 1;
1940
1941         ret = wlan_set_wep_key(assoc_req, extra, dwrq->length, index, set_tx_key);
1942         if (ret)
1943                 goto out;
1944
1945         if (dwrq->length)
1946                 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1947         if (set_tx_key)
1948                 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
1949
1950         if (dwrq->flags & IW_ENCODE_RESTRICTED) {
1951                 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
1952         } else if (dwrq->flags & IW_ENCODE_OPEN) {
1953                 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1954         }
1955
1956 out:
1957         if (ret == 0) {
1958                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1959                 wlan_postpone_association_work(priv);
1960         } else {
1961                 wlan_cancel_association_work(priv);
1962         }
1963         mutex_unlock(&adapter->lock);
1964
1965         LEAVE();
1966         return ret;
1967 }
1968
1969 /**
1970  *  @brief Get Extended Encryption key (WPA/802.1x and WEP)
1971  *
1972  *  @param dev                  A pointer to net_device structure
1973  *  @param info                 A pointer to iw_request_info structure
1974  *  @param vwrq                 A pointer to iw_param structure
1975  *  @param extra                A pointer to extra data buf
1976  *  @return                     0 on success, otherwise failure
1977  */
1978 static int wlan_get_encodeext(struct net_device *dev,
1979                               struct iw_request_info *info,
1980                               struct iw_point *dwrq,
1981                               char *extra)
1982 {
1983         int ret = -EINVAL;
1984         wlan_private *priv = dev->priv;
1985         wlan_adapter *adapter = priv->adapter;
1986         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1987         int index, max_key_len;
1988
1989         ENTER();
1990
1991         max_key_len = dwrq->length - sizeof(*ext);
1992         if (max_key_len < 0)
1993                 goto out;
1994
1995         index = dwrq->flags & IW_ENCODE_INDEX;
1996         if (index) {
1997                 if (index < 1 || index > 4)
1998                         goto out;
1999                 index--;
2000         } else {
2001                 index = adapter->wep_tx_keyidx;
2002         }
2003
2004         if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
2005             ext->alg != IW_ENCODE_ALG_WEP) {
2006                 if (index != 0 || adapter->mode != IW_MODE_INFRA)
2007                         goto out;
2008         }
2009
2010         dwrq->flags = index + 1;
2011         memset(ext, 0, sizeof(*ext));
2012
2013         if (   !adapter->secinfo.wep_enabled
2014             && !adapter->secinfo.WPAenabled
2015             && !adapter->secinfo.WPA2enabled) {
2016                 ext->alg = IW_ENCODE_ALG_NONE;
2017                 ext->key_len = 0;
2018                 dwrq->flags |= IW_ENCODE_DISABLED;
2019         } else {
2020                 u8 *key = NULL;
2021
2022                 if (   adapter->secinfo.wep_enabled
2023                     && !adapter->secinfo.WPAenabled
2024                     && !adapter->secinfo.WPA2enabled) {
2025                         ext->alg = IW_ENCODE_ALG_WEP;
2026                         ext->key_len = adapter->wep_keys[index].len;
2027                         key = &adapter->wep_keys[index].key[0];
2028                 } else if (   !adapter->secinfo.wep_enabled
2029                            && (adapter->secinfo.WPAenabled ||
2030                                adapter->secinfo.WPA2enabled)) {
2031                         /* WPA */
2032                         ext->alg = IW_ENCODE_ALG_TKIP;
2033                         ext->key_len = 0;
2034                 } else {
2035                         goto out;
2036                 }
2037
2038                 if (ext->key_len > max_key_len) {
2039                         ret = -E2BIG;
2040                         goto out;
2041                 }
2042
2043                 if (ext->key_len)
2044                         memcpy(ext->key, key, ext->key_len);
2045                 else
2046                         dwrq->flags |= IW_ENCODE_NOKEY;
2047                 dwrq->flags |= IW_ENCODE_ENABLED;
2048         }
2049         ret = 0;
2050
2051 out:
2052         LEAVE();
2053         return ret;
2054 }
2055
2056 /**
2057  *  @brief Set Encryption key Extended (WPA/802.1x and WEP)
2058  *
2059  *  @param dev                  A pointer to net_device structure
2060  *  @param info                 A pointer to iw_request_info structure
2061  *  @param vwrq                 A pointer to iw_param structure
2062  *  @param extra                A pointer to extra data buf
2063  *  @return                     0 --success, otherwise fail
2064  */
2065 static int wlan_set_encodeext(struct net_device *dev,
2066                               struct iw_request_info *info,
2067                               struct iw_point *dwrq,
2068                               char *extra)
2069 {
2070         int ret = 0;
2071         wlan_private *priv = dev->priv;
2072         wlan_adapter *adapter = priv->adapter;
2073         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2074         int alg = ext->alg;
2075         struct assoc_request * assoc_req;
2076
2077         ENTER();
2078
2079         mutex_lock(&adapter->lock);
2080         assoc_req = wlan_get_association_request(adapter);
2081         if (!assoc_req) {
2082                 ret = -ENOMEM;
2083                 goto out;
2084         }
2085
2086         if ((alg == IW_ENCODE_ALG_NONE) || (dwrq->flags & IW_ENCODE_DISABLED)) {
2087                 disable_wep (assoc_req);
2088         } else if (alg == IW_ENCODE_ALG_WEP) {
2089                 u16 is_default = 0, index, set_tx_key = 0;
2090
2091                 ret = validate_key_index(assoc_req->wep_tx_keyidx,
2092                                          (dwrq->flags & IW_ENCODE_INDEX),
2093                                          &index, &is_default);
2094                 if (ret)
2095                         goto out;
2096
2097                 /* If WEP isn't enabled, or if there is no key data but a valid
2098                  * index, or if the set-TX-key flag was passed, set the TX key.
2099                  */
2100                 if (   !assoc_req->secinfo.wep_enabled
2101                     || (dwrq->length == 0 && !is_default)
2102                     || (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY))
2103                         set_tx_key = 1;
2104
2105                 /* Copy key to driver */
2106                 ret = wlan_set_wep_key (assoc_req, ext->key, ext->key_len, index,
2107                                         set_tx_key);
2108                 if (ret)
2109                         goto out;
2110
2111                 if (dwrq->flags & IW_ENCODE_RESTRICTED) {
2112                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
2113                 } else if (dwrq->flags & IW_ENCODE_OPEN) {
2114                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2115                 }
2116
2117                 /* Mark the various WEP bits as modified */
2118                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2119                 if (dwrq->length)
2120                         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
2121                 if (set_tx_key)
2122                         set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
2123
2124         } else if ((alg == IW_ENCODE_ALG_TKIP) || (alg == IW_ENCODE_ALG_CCMP)) {
2125                 struct WLAN_802_11_KEY * pkey;
2126
2127                 /* validate key length */
2128                 if (((alg == IW_ENCODE_ALG_TKIP)
2129                         && (ext->key_len != KEY_LEN_WPA_TKIP))
2130                     || ((alg == IW_ENCODE_ALG_CCMP)
2131                         && (ext->key_len != KEY_LEN_WPA_AES))) {
2132                                 lbs_pr_debug(1, "Invalid size %d for key of alg"
2133                                        "type %d.\n",
2134                                        ext->key_len,
2135                                        alg);
2136                                 ret = -EINVAL;
2137                                 goto out;
2138                 }
2139
2140                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
2141                         pkey = &assoc_req->wpa_mcast_key;
2142                 else
2143                         pkey = &assoc_req->wpa_unicast_key;
2144
2145                 memset(pkey, 0, sizeof (struct WLAN_802_11_KEY));
2146                 memcpy(pkey->key, ext->key, ext->key_len);
2147                 pkey->len = ext->key_len;
2148                 pkey->flags = KEY_INFO_WPA_ENABLED;
2149
2150                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
2151                         pkey->flags |= KEY_INFO_WPA_MCAST;
2152                         set_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
2153                 } else {
2154                         pkey->flags |= KEY_INFO_WPA_UNICAST;
2155                         set_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
2156                 }
2157
2158                 if (alg == IW_ENCODE_ALG_TKIP)
2159                         pkey->type = KEY_TYPE_ID_TKIP;
2160                 else if (alg == IW_ENCODE_ALG_CCMP)
2161                         pkey->type = KEY_TYPE_ID_AES;
2162
2163                 /* If WPA isn't enabled yet, do that now */
2164                 if (   assoc_req->secinfo.WPAenabled == 0
2165                     && assoc_req->secinfo.WPA2enabled == 0) {
2166                         assoc_req->secinfo.WPAenabled = 1;
2167                         assoc_req->secinfo.WPA2enabled = 1;
2168                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2169                 }
2170
2171                 disable_wep (assoc_req);
2172         }
2173
2174 out:
2175         if (ret == 0) {
2176                 wlan_postpone_association_work(priv);
2177         } else {
2178                 wlan_cancel_association_work(priv);
2179         }
2180         mutex_unlock(&adapter->lock);
2181
2182         LEAVE();
2183         return ret;
2184 }
2185
2186
2187 static int wlan_set_genie(struct net_device *dev,
2188                           struct iw_request_info *info,
2189                           struct iw_point *dwrq,
2190                           char *extra)
2191 {
2192         wlan_private *priv = dev->priv;
2193         wlan_adapter *adapter = priv->adapter;
2194         int ret = 0;
2195         struct assoc_request * assoc_req;
2196
2197         ENTER();
2198
2199         mutex_lock(&adapter->lock);
2200         assoc_req = wlan_get_association_request(adapter);
2201         if (!assoc_req) {
2202                 ret = -ENOMEM;
2203                 goto out;
2204         }
2205
2206         if (dwrq->length > MAX_WPA_IE_LEN ||
2207             (dwrq->length && extra == NULL)) {
2208                 ret = -EINVAL;
2209                 goto out;
2210         }
2211
2212         if (dwrq->length) {
2213                 memcpy(&assoc_req->wpa_ie[0], extra, dwrq->length);
2214                 assoc_req->wpa_ie_len = dwrq->length;
2215         } else {
2216                 memset(&assoc_req->wpa_ie[0], 0, sizeof(adapter->wpa_ie));
2217                 assoc_req->wpa_ie_len = 0;
2218         }
2219
2220 out:
2221         if (ret == 0) {
2222                 set_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags);
2223                 wlan_postpone_association_work(priv);
2224         } else {
2225                 wlan_cancel_association_work(priv);
2226         }
2227         mutex_unlock(&adapter->lock);
2228
2229         LEAVE();
2230         return ret;
2231 }
2232
2233 static int wlan_get_genie(struct net_device *dev,
2234                           struct iw_request_info *info,
2235                           struct iw_point *dwrq,
2236                           char *extra)
2237 {
2238         wlan_private *priv = dev->priv;
2239         wlan_adapter *adapter = priv->adapter;
2240
2241         ENTER();
2242
2243         if (adapter->wpa_ie_len == 0) {
2244                 dwrq->length = 0;
2245                 LEAVE();
2246                 return 0;
2247         }
2248
2249         if (dwrq->length < adapter->wpa_ie_len) {
2250                 LEAVE();
2251                 return -E2BIG;
2252         }
2253
2254         dwrq->length = adapter->wpa_ie_len;
2255         memcpy(extra, &adapter->wpa_ie[0], adapter->wpa_ie_len);
2256
2257         LEAVE();
2258         return 0;
2259 }
2260
2261
2262 static int wlan_set_auth(struct net_device *dev,
2263                          struct iw_request_info *info,
2264                          struct iw_param *dwrq,
2265                          char *extra)
2266 {
2267         wlan_private *priv = dev->priv;
2268         wlan_adapter *adapter = priv->adapter;
2269         struct assoc_request * assoc_req;
2270         int ret = 0;
2271         int updated = 0;
2272
2273         ENTER();
2274
2275         mutex_lock(&adapter->lock);
2276         assoc_req = wlan_get_association_request(adapter);
2277         if (!assoc_req) {
2278                 ret = -ENOMEM;
2279                 goto out;
2280         }
2281
2282         switch (dwrq->flags & IW_AUTH_INDEX) {
2283         case IW_AUTH_TKIP_COUNTERMEASURES:
2284         case IW_AUTH_CIPHER_PAIRWISE:
2285         case IW_AUTH_CIPHER_GROUP:
2286         case IW_AUTH_KEY_MGMT:
2287                 /*
2288                  * libertas does not use these parameters
2289                  */
2290                 break;
2291
2292         case IW_AUTH_WPA_VERSION:
2293                 if (dwrq->value & IW_AUTH_WPA_VERSION_DISABLED) {
2294                         assoc_req->secinfo.WPAenabled = 0;
2295                         assoc_req->secinfo.WPA2enabled = 0;
2296                 }
2297                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA) {
2298                         assoc_req->secinfo.WPAenabled = 1;
2299                         assoc_req->secinfo.wep_enabled = 0;
2300                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2301                 }
2302                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA2) {
2303                         assoc_req->secinfo.WPA2enabled = 1;
2304                         assoc_req->secinfo.wep_enabled = 0;
2305                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2306                 }
2307                 updated = 1;
2308                 break;
2309
2310         case IW_AUTH_DROP_UNENCRYPTED:
2311                 if (dwrq->value) {
2312                         adapter->currentpacketfilter |=
2313                             cmd_act_mac_strict_protection_enable;
2314                 } else {
2315                         adapter->currentpacketfilter &=
2316                             ~cmd_act_mac_strict_protection_enable;
2317                 }
2318                 updated = 1;
2319                 break;
2320
2321         case IW_AUTH_80211_AUTH_ALG:
2322                 if (dwrq->value & IW_AUTH_ALG_SHARED_KEY) {
2323                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
2324                 } else if (dwrq->value & IW_AUTH_ALG_OPEN_SYSTEM) {
2325                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2326                 } else if (dwrq->value & IW_AUTH_ALG_LEAP) {
2327                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_LEAP;
2328                 } else {
2329                         ret = -EINVAL;
2330                 }
2331                 updated = 1;
2332                 break;
2333
2334         case IW_AUTH_WPA_ENABLED:
2335                 if (dwrq->value) {
2336                         if (!assoc_req->secinfo.WPAenabled &&
2337                             !assoc_req->secinfo.WPA2enabled) {
2338                                 assoc_req->secinfo.WPAenabled = 1;
2339                                 assoc_req->secinfo.WPA2enabled = 1;
2340                                 assoc_req->secinfo.wep_enabled = 0;
2341                                 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
2342                         }
2343                 } else {
2344                         assoc_req->secinfo.WPAenabled = 0;
2345                         assoc_req->secinfo.WPA2enabled = 0;
2346                 }
2347                 updated = 1;
2348                 break;
2349
2350         default:
2351                 ret = -EOPNOTSUPP;
2352                 break;
2353         }
2354
2355 out:
2356         if (ret == 0) {
2357                 if (updated)
2358                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2359                 wlan_postpone_association_work(priv);
2360         } else if (ret != -EOPNOTSUPP) {
2361                 wlan_cancel_association_work(priv);
2362         }
2363         mutex_unlock(&adapter->lock);
2364
2365         LEAVE();
2366         return ret;
2367 }
2368
2369 static int wlan_get_auth(struct net_device *dev,
2370                          struct iw_request_info *info,
2371                          struct iw_param *dwrq,
2372                          char *extra)
2373 {
2374         wlan_private *priv = dev->priv;
2375         wlan_adapter *adapter = priv->adapter;
2376
2377         ENTER();
2378
2379         switch (dwrq->flags & IW_AUTH_INDEX) {
2380         case IW_AUTH_WPA_VERSION:
2381                 dwrq->value = 0;
2382                 if (adapter->secinfo.WPAenabled)
2383                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA;
2384                 if (adapter->secinfo.WPA2enabled)
2385                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA2;
2386                 if (!dwrq->value)
2387                         dwrq->value |= IW_AUTH_WPA_VERSION_DISABLED;
2388                 break;
2389
2390         case IW_AUTH_DROP_UNENCRYPTED:
2391                 dwrq->value = 0;
2392                 if (adapter->currentpacketfilter &
2393                     cmd_act_mac_strict_protection_enable)
2394                         dwrq->value = 1;
2395                 break;
2396
2397         case IW_AUTH_80211_AUTH_ALG:
2398                 dwrq->value = adapter->secinfo.auth_mode;
2399                 break;
2400
2401         case IW_AUTH_WPA_ENABLED:
2402                 if (adapter->secinfo.WPAenabled && adapter->secinfo.WPA2enabled)
2403                         dwrq->value = 1;
2404                 break;
2405
2406         default:
2407                 LEAVE();
2408                 return -EOPNOTSUPP;
2409         }
2410
2411         LEAVE();
2412         return 0;
2413 }
2414
2415
2416 static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
2417                    struct iw_param *vwrq, char *extra)
2418 {
2419         int ret = 0;
2420         wlan_private *priv = dev->priv;
2421         wlan_adapter *adapter = priv->adapter;
2422
2423         u16 dbm;
2424
2425         ENTER();
2426
2427         if (vwrq->disabled) {
2428                 wlan_radio_ioctl(priv, RADIO_OFF);
2429                 return 0;
2430         }
2431
2432         adapter->preamble = cmd_type_auto_preamble;
2433
2434         wlan_radio_ioctl(priv, RADIO_ON);
2435
2436         if ((vwrq->flags & IW_TXPOW_TYPE) == IW_TXPOW_MWATT) {
2437                 dbm = (u16) mw_to_dbm(vwrq->value);
2438         } else
2439                 dbm = (u16) vwrq->value;
2440
2441         /* auto tx power control */
2442
2443         if (vwrq->fixed == 0)
2444                 dbm = 0xffff;
2445
2446         lbs_pr_debug(1, "<1>TXPOWER SET %d dbm.\n", dbm);
2447
2448         ret = libertas_prepare_and_send_command(priv,
2449                                     cmd_802_11_rf_tx_power,
2450                                     cmd_act_tx_power_opt_set_low,
2451                                     cmd_option_waitforrsp, 0, (void *)&dbm);
2452
2453         LEAVE();
2454         return ret;
2455 }
2456
2457 static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
2458                    struct iw_point *dwrq, char *extra)
2459 {
2460         wlan_private *priv = dev->priv;
2461         wlan_adapter *adapter = priv->adapter;
2462
2463         ENTER();
2464         /*
2465          * Note : if dwrq->flags != 0, we should get the relevant SSID from
2466          * the SSID list...
2467          */
2468
2469         /*
2470          * Get the current SSID
2471          */
2472         if (adapter->connect_status == libertas_connected) {
2473                 memcpy(extra, adapter->curbssparams.ssid.ssid,
2474                        adapter->curbssparams.ssid.ssidlength);
2475                 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2476         } else {
2477                 memset(extra, 0, 32);
2478                 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2479         }
2480         /*
2481          * If none, we may want to get the one that was set
2482          */
2483
2484         /* To make the driver backward compatible with WPA supplicant v0.2.4 */
2485         if (dwrq->length == 32) /* check with WPA supplicant buffer size */
2486                 dwrq->length = min_t(size_t, adapter->curbssparams.ssid.ssidlength,
2487                                    IW_ESSID_MAX_SIZE);
2488         else
2489                 dwrq->length = adapter->curbssparams.ssid.ssidlength + 1;
2490
2491         dwrq->flags = 1;        /* active */
2492
2493         LEAVE();
2494         return 0;
2495 }
2496
2497 static int wlan_set_essid(struct net_device *dev, struct iw_request_info *info,
2498                    struct iw_point *dwrq, char *extra)
2499 {
2500         wlan_private *priv = dev->priv;
2501         wlan_adapter *adapter = priv->adapter;
2502         int ret = 0;
2503         struct WLAN_802_11_SSID ssid;
2504         struct assoc_request * assoc_req;
2505         int ssid_len = dwrq->length;
2506
2507         ENTER();
2508
2509         /*
2510          * WE-20 and earlier NULL pad the end of the SSID and increment
2511          * SSID length so it can be used like a string.  WE-21 and later don't,
2512          * but some userspace tools aren't able to cope with the change.
2513          */
2514         if ((ssid_len > 0) && (extra[ssid_len - 1] == '\0'))
2515                 ssid_len--;
2516
2517         /* Check the size of the string */
2518         if (ssid_len > IW_ESSID_MAX_SIZE) {
2519                 ret = -E2BIG;
2520                 goto out;
2521         }
2522
2523         memset(&ssid, 0, sizeof(struct WLAN_802_11_SSID));
2524
2525         if (!dwrq->flags || !ssid_len) {
2526                 /* "any" SSID requested; leave SSID blank */
2527         } else {
2528                 /* Specific SSID requested */
2529                 memcpy(&ssid.ssid, extra, ssid_len);
2530                 ssid.ssidlength = ssid_len;
2531         }
2532
2533         lbs_pr_debug(1, "Requested new SSID = %s\n",
2534                (ssid.ssidlength > 0) ? (char *)ssid.ssid : "any");
2535
2536 out:
2537         mutex_lock(&adapter->lock);
2538         if (ret == 0) {
2539                 /* Get or create the current association request */
2540                 assoc_req = wlan_get_association_request(adapter);
2541                 if (!assoc_req) {
2542                         ret = -ENOMEM;
2543                 } else {
2544                         /* Copy the SSID to the association request */
2545                         memcpy(&assoc_req->ssid, &ssid, sizeof(struct WLAN_802_11_SSID));
2546                         set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
2547                         wlan_postpone_association_work(priv);
2548                 }
2549         }
2550
2551         /* Cancel the association request if there was an error */
2552         if (ret != 0) {
2553                 wlan_cancel_association_work(priv);
2554         }
2555
2556         mutex_unlock(&adapter->lock);
2557
2558         LEAVE();
2559         return ret;
2560 }
2561
2562 /**
2563  *  @brief Connect to the AP or Ad-hoc Network with specific bssid
2564  *
2565  *  @param dev          A pointer to net_device structure
2566  *  @param info         A pointer to iw_request_info structure
2567  *  @param awrq         A pointer to iw_param structure
2568  *  @param extra        A pointer to extra data buf
2569  *  @return             0 --success, otherwise fail
2570  */
2571 static int wlan_set_wap(struct net_device *dev, struct iw_request_info *info,
2572                  struct sockaddr *awrq, char *extra)
2573 {
2574         wlan_private *priv = dev->priv;
2575         wlan_adapter *adapter = priv->adapter;
2576         struct assoc_request * assoc_req;
2577         int ret = 0;
2578
2579         ENTER();
2580
2581         if (awrq->sa_family != ARPHRD_ETHER)
2582                 return -EINVAL;
2583
2584         lbs_pr_debug(1, "ASSOC: WAP: sa_data: " MAC_FMT "\n", MAC_ARG(awrq->sa_data));
2585
2586         mutex_lock(&adapter->lock);
2587
2588         /* Get or create the current association request */
2589         assoc_req = wlan_get_association_request(adapter);
2590         if (!assoc_req) {
2591                 wlan_cancel_association_work(priv);
2592                 ret = -ENOMEM;
2593         } else {
2594                 /* Copy the BSSID to the association request */
2595                 memcpy(&assoc_req->bssid, awrq->sa_data, ETH_ALEN);
2596                 set_bit(ASSOC_FLAG_BSSID, &assoc_req->flags);
2597                 wlan_postpone_association_work(priv);
2598         }
2599
2600         mutex_unlock(&adapter->lock);
2601
2602         return ret;
2603 }
2604
2605 void libertas_get_fwversion(wlan_adapter * adapter, char *fwversion, int maxlen)
2606 {
2607         union {
2608                 u32 l;
2609                 u8 c[4];
2610         } ver;
2611         char fwver[32];
2612
2613         mutex_lock(&adapter->lock);
2614         ver.l = adapter->fwreleasenumber;
2615         mutex_unlock(&adapter->lock);
2616
2617         if (ver.c[3] == 0)
2618                 sprintf(fwver, "%u.%u.%u", ver.c[2], ver.c[1], ver.c[0]);
2619         else
2620                 sprintf(fwver, "%u.%u.%u.p%u",
2621                         ver.c[2], ver.c[1], ver.c[0], ver.c[3]);
2622
2623         snprintf(fwversion, maxlen, fwver);
2624 }
2625
2626
2627 /*
2628  * iwconfig settable callbacks
2629  */
2630 static const iw_handler wlan_handler[] = {
2631         (iw_handler) NULL,      /* SIOCSIWCOMMIT */
2632         (iw_handler) wlan_get_name,     /* SIOCGIWNAME */
2633         (iw_handler) NULL,      /* SIOCSIWNWID */
2634         (iw_handler) NULL,      /* SIOCGIWNWID */
2635         (iw_handler) wlan_set_freq,     /* SIOCSIWFREQ */
2636         (iw_handler) wlan_get_freq,     /* SIOCGIWFREQ */
2637         (iw_handler) wlan_set_mode,     /* SIOCSIWMODE */
2638         (iw_handler) wlan_get_mode,     /* SIOCGIWMODE */
2639         (iw_handler) NULL,      /* SIOCSIWSENS */
2640         (iw_handler) NULL,      /* SIOCGIWSENS */
2641         (iw_handler) NULL,      /* SIOCSIWRANGE */
2642         (iw_handler) wlan_get_range,    /* SIOCGIWRANGE */
2643         (iw_handler) NULL,      /* SIOCSIWPRIV */
2644         (iw_handler) NULL,      /* SIOCGIWPRIV */
2645         (iw_handler) NULL,      /* SIOCSIWSTATS */
2646         (iw_handler) NULL,      /* SIOCGIWSTATS */
2647         iw_handler_set_spy,     /* SIOCSIWSPY */
2648         iw_handler_get_spy,     /* SIOCGIWSPY */
2649         iw_handler_set_thrspy,  /* SIOCSIWTHRSPY */
2650         iw_handler_get_thrspy,  /* SIOCGIWTHRSPY */
2651         (iw_handler) wlan_set_wap,      /* SIOCSIWAP */
2652         (iw_handler) wlan_get_wap,      /* SIOCGIWAP */
2653         (iw_handler) NULL,      /* SIOCSIWMLME */
2654         (iw_handler) NULL,      /* SIOCGIWAPLIST - deprecated */
2655         (iw_handler) libertas_set_scan, /* SIOCSIWSCAN */
2656         (iw_handler) libertas_get_scan, /* SIOCGIWSCAN */
2657         (iw_handler) wlan_set_essid,    /* SIOCSIWESSID */
2658         (iw_handler) wlan_get_essid,    /* SIOCGIWESSID */
2659         (iw_handler) wlan_set_nick,     /* SIOCSIWNICKN */
2660         (iw_handler) wlan_get_nick,     /* SIOCGIWNICKN */
2661         (iw_handler) NULL,      /* -- hole -- */
2662         (iw_handler) NULL,      /* -- hole -- */
2663         (iw_handler) wlan_set_rate,     /* SIOCSIWRATE */
2664         (iw_handler) wlan_get_rate,     /* SIOCGIWRATE */
2665         (iw_handler) wlan_set_rts,      /* SIOCSIWRTS */
2666         (iw_handler) wlan_get_rts,      /* SIOCGIWRTS */
2667         (iw_handler) wlan_set_frag,     /* SIOCSIWFRAG */
2668         (iw_handler) wlan_get_frag,     /* SIOCGIWFRAG */
2669         (iw_handler) wlan_set_txpow,    /* SIOCSIWTXPOW */
2670         (iw_handler) wlan_get_txpow,    /* SIOCGIWTXPOW */
2671         (iw_handler) wlan_set_retry,    /* SIOCSIWRETRY */
2672         (iw_handler) wlan_get_retry,    /* SIOCGIWRETRY */
2673         (iw_handler) wlan_set_encode,   /* SIOCSIWENCODE */
2674         (iw_handler) wlan_get_encode,   /* SIOCGIWENCODE */
2675         (iw_handler) wlan_set_power,    /* SIOCSIWPOWER */
2676         (iw_handler) wlan_get_power,    /* SIOCGIWPOWER */
2677         (iw_handler) NULL,      /* -- hole -- */
2678         (iw_handler) NULL,      /* -- hole -- */
2679         (iw_handler) wlan_set_genie,    /* SIOCSIWGENIE */
2680         (iw_handler) wlan_get_genie,    /* SIOCGIWGENIE */
2681         (iw_handler) wlan_set_auth,     /* SIOCSIWAUTH */
2682         (iw_handler) wlan_get_auth,     /* SIOCGIWAUTH */
2683         (iw_handler) wlan_set_encodeext,/* SIOCSIWENCODEEXT */
2684         (iw_handler) wlan_get_encodeext,/* SIOCGIWENCODEEXT */
2685         (iw_handler) NULL,              /* SIOCSIWPMKSA */
2686 };
2687
2688 struct iw_handler_def libertas_handler_def = {
2689         .num_standard   = sizeof(wlan_handler) / sizeof(iw_handler),
2690         .num_private    = sizeof(wlan_private_handler) / sizeof(iw_handler),
2691         .num_private_args = sizeof(wlan_private_args) /
2692                 sizeof(struct iw_priv_args),
2693         .standard       = (iw_handler *) wlan_handler,
2694         .private        = (iw_handler *) wlan_private_handler,
2695         .private_args   = (struct iw_priv_args *)wlan_private_args,
2696         .get_wireless_stats = wlan_get_wireless_stats,
2697 };