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