SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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.WEPstatus ==
1560                                     wlan802_11WEPenabled) {
1561                                         lbs_pr_debug(1, "set_freq: WEP enabled\n");
1562                                         ret = libertas_prepare_and_send_command(priv,
1563                                                                     cmd_802_11_set_wep,
1564                                                                     cmd_act_add,
1565                                                                     cmd_option_waitforrsp,
1566                                                                     0,
1567                                                                     NULL);
1568
1569                                         if (ret) {
1570                                                 LEAVE();
1571                                                 return ret;
1572                                         }
1573
1574                                         adapter->currentpacketfilter |=
1575                                             cmd_act_mac_wep_enable;
1576
1577                                         libertas_set_mac_packet_filter(priv);
1578                                 }
1579                         } else {
1580                                 rc = -EOPNOTSUPP;
1581                         }
1582                 }
1583         }
1584
1585         LEAVE();
1586         return rc;
1587 }
1588
1589 /**
1590  *  @brief use index to get the data rate
1591  *
1592  *  @param index                The index of data rate
1593  *  @return                     data rate or 0
1594  */
1595 u32 libertas_index_to_data_rate(u8 index)
1596 {
1597         if (index >= sizeof(libertas_wlan_data_rates))
1598                 index = 0;
1599
1600         return libertas_wlan_data_rates[index];
1601 }
1602
1603 /**
1604  *  @brief use rate to get the index
1605  *
1606  *  @param rate                 data rate
1607  *  @return                     index or 0
1608  */
1609 u8 libertas_data_rate_to_index(u32 rate)
1610 {
1611         u8 *ptr;
1612
1613         if (rate)
1614                 if ((ptr = memchr(libertas_wlan_data_rates, (u8) rate,
1615                                   sizeof(libertas_wlan_data_rates))))
1616                         return (ptr - libertas_wlan_data_rates);
1617
1618         return 0;
1619 }
1620
1621 static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
1622                   struct iw_param *vwrq, char *extra)
1623 {
1624         wlan_private *priv = dev->priv;
1625         wlan_adapter *adapter = priv->adapter;
1626         u32 data_rate;
1627         u16 action;
1628         int ret = 0;
1629         u8 rates[WLAN_SUPPORTED_RATES];
1630         u8 *rate;
1631
1632         ENTER();
1633
1634         lbs_pr_debug(1, "Vwrq->value = %d\n", vwrq->value);
1635
1636         if (vwrq->value == -1) {
1637                 action = cmd_act_set_tx_auto;   // Auto
1638                 adapter->is_datarate_auto = 1;
1639                 adapter->datarate = 0;
1640         } else {
1641                 if (vwrq->value % 100000) {
1642                         return -EINVAL;
1643                 }
1644
1645                 data_rate = vwrq->value / 500000;
1646
1647                 memset(rates, 0, sizeof(rates));
1648                 get_active_data_rates(adapter, rates);
1649                 rate = rates;
1650                 while (*rate) {
1651                         lbs_pr_debug(1, "Rate=0x%X  Wanted=0x%X\n", *rate,
1652                                data_rate);
1653                         if ((*rate & 0x7f) == (data_rate & 0x7f))
1654                                 break;
1655                         rate++;
1656                 }
1657                 if (!*rate) {
1658                         lbs_pr_alert( "The fixed data rate 0x%X is out "
1659                                "of range.\n", data_rate);
1660                         return -EINVAL;
1661                 }
1662
1663                 adapter->datarate = data_rate;
1664                 action = cmd_act_set_tx_fix_rate;
1665                 adapter->is_datarate_auto = 0;
1666         }
1667
1668         ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
1669                                     action, cmd_option_waitforrsp, 0, NULL);
1670
1671         LEAVE();
1672         return ret;
1673 }
1674
1675 static int wlan_get_rate(struct net_device *dev, struct iw_request_info *info,
1676                   struct iw_param *vwrq, char *extra)
1677 {
1678         wlan_private *priv = dev->priv;
1679         wlan_adapter *adapter = priv->adapter;
1680
1681         ENTER();
1682
1683         if (adapter->is_datarate_auto) {
1684                 vwrq->fixed = 0;
1685         } else {
1686                 vwrq->fixed = 1;
1687         }
1688
1689         vwrq->value = adapter->datarate * 500000;
1690
1691         LEAVE();
1692         return 0;
1693 }
1694
1695 static int wlan_set_mode(struct net_device *dev,
1696                   struct iw_request_info *info, u32 * uwrq, char *extra)
1697 {
1698         int ret = 0;
1699         wlan_private *priv = dev->priv;
1700         wlan_adapter *adapter = priv->adapter;
1701         struct assoc_request * assoc_req;
1702         enum WLAN_802_11_NETWORK_INFRASTRUCTURE new_mode;
1703
1704         ENTER();
1705
1706         switch (*uwrq) {
1707         case IW_MODE_ADHOC:
1708                 lbs_pr_debug(1, "Wanted mode is ad-hoc: current datarate=%#x\n",
1709                        adapter->datarate);
1710                 new_mode = wlan802_11ibss;
1711                 adapter->adhocchannel = DEFAULT_AD_HOC_CHANNEL;
1712                 break;
1713
1714         case IW_MODE_INFRA:
1715                 lbs_pr_debug(1, "Wanted mode is Infrastructure\n");
1716                 new_mode = wlan802_11infrastructure;
1717                 break;
1718
1719         case IW_MODE_AUTO:
1720                 lbs_pr_debug(1, "Wanted mode is Auto\n");
1721                 new_mode = wlan802_11autounknown;
1722                 break;
1723
1724         default:
1725                 lbs_pr_debug(1, "Wanted mode is Unknown: 0x%x\n", *uwrq);
1726                 return -EINVAL;
1727         }
1728
1729         mutex_lock(&adapter->lock);
1730         assoc_req = wlan_get_association_request(adapter);
1731         if (!assoc_req) {
1732                 ret = -ENOMEM;
1733         } else {
1734                 assoc_req->mode = new_mode;
1735         }
1736
1737         if (ret == 0) {
1738                 set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
1739                 wlan_postpone_association_work(priv);
1740         } else {
1741                 wlan_cancel_association_work(priv);
1742         }
1743         mutex_unlock(&adapter->lock);
1744
1745         LEAVE();
1746         return ret;
1747 }
1748
1749
1750 /**
1751  *  @brief Get Encryption key
1752  *
1753  *  @param dev                  A pointer to net_device structure
1754  *  @param info                 A pointer to iw_request_info structure
1755  *  @param vwrq                 A pointer to iw_param structure
1756  *  @param extra                A pointer to extra data buf
1757  *  @return                     0 --success, otherwise fail
1758  */
1759 static int wlan_get_encode(struct net_device *dev,
1760                            struct iw_request_info *info,
1761                            struct iw_point *dwrq, u8 * extra)
1762 {
1763         wlan_private *priv = dev->priv;
1764         wlan_adapter *adapter = priv->adapter;
1765         int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1766
1767         ENTER();
1768
1769         lbs_pr_debug(1, "flags=0x%x index=%d length=%d wep_tx_keyidx=%d\n",
1770                dwrq->flags, index, dwrq->length, adapter->wep_tx_keyidx);
1771
1772         dwrq->flags = 0;
1773
1774         /* Authentication method */
1775         switch (adapter->secinfo.authmode) {
1776         case wlan802_11authmodeopen:
1777                 dwrq->flags = IW_ENCODE_OPEN;
1778                 break;
1779
1780         case wlan802_11authmodeshared:
1781         case wlan802_11authmodenetworkEAP:
1782                 dwrq->flags = IW_ENCODE_RESTRICTED;
1783                 break;
1784         default:
1785                 dwrq->flags = IW_ENCODE_DISABLED | IW_ENCODE_OPEN;
1786                 break;
1787         }
1788
1789         if ((adapter->secinfo.WEPstatus == wlan802_11WEPenabled)
1790             || adapter->secinfo.WPAenabled || 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) &&
1805             (adapter->secinfo.WEPstatus == wlan802_11WEPenabled)) {
1806                 memcpy(extra, adapter->wep_keys[index].key,
1807                        adapter->wep_keys[index].len);
1808                 dwrq->length = adapter->wep_keys[index].len;
1809
1810                 dwrq->flags |= (index + 1);
1811                 /* Return WEP enabled */
1812                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1813         } else if ((adapter->secinfo.WPAenabled)
1814                    || (adapter->secinfo.WPA2enabled)) {
1815                 /* return WPA enabled */
1816                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1817         } else {
1818                 dwrq->flags |= IW_ENCODE_DISABLED;
1819         }
1820
1821         mutex_unlock(&adapter->lock);
1822
1823         dwrq->flags |= IW_ENCODE_NOKEY;
1824
1825         lbs_pr_debug(1, "key:%02x:%02x:%02x:%02x:%02x:%02x keylen=%d\n",
1826                extra[0], extra[1], extra[2],
1827                extra[3], extra[4], extra[5], dwrq->length);
1828
1829         lbs_pr_debug(1, "Return flags=0x%x\n", dwrq->flags);
1830
1831         LEAVE();
1832         return 0;
1833 }
1834
1835 /**
1836  *  @brief Set Encryption key (internal)
1837  *
1838  *  @param priv                 A pointer to private card structure
1839  *  @param key_material         A pointer to key material
1840  *  @param key_length           length of key material
1841  *  @param index                key index to set
1842  *  @param set_tx_key           Force set TX key (1 = yes, 0 = no)
1843  *  @return                     0 --success, otherwise fail
1844  */
1845 static int wlan_set_wep_key(struct assoc_request *assoc_req,
1846                             const char *key_material,
1847                             u16 key_length,
1848                             u16 index,
1849                             int set_tx_key)
1850 {
1851         struct WLAN_802_11_KEY *pkey;
1852
1853         ENTER();
1854
1855         /* Paranoid validation of key index */
1856         if (index > 3) {
1857                 LEAVE();
1858                 return -EINVAL;
1859         }
1860
1861         /* validate max key length */
1862         if (key_length > KEY_LEN_WEP_104) {
1863                 LEAVE();
1864                 return -EINVAL;
1865         }
1866
1867         pkey = &assoc_req->wep_keys[index];
1868
1869         if (key_length > 0) {
1870                 memset(pkey, 0, sizeof(struct WLAN_802_11_KEY));
1871                 pkey->type = KEY_TYPE_ID_WEP;
1872
1873                 /* Standardize the key length */
1874                 pkey->len = (key_length > KEY_LEN_WEP_40) ?
1875                                 KEY_LEN_WEP_104 : KEY_LEN_WEP_40;
1876                 memcpy(pkey->key, key_material, key_length);
1877         }
1878
1879         if (set_tx_key) {
1880                 /* Ensure the chosen key is valid */
1881                 if (!pkey->len) {
1882                         lbs_pr_debug(1, "key not set, so cannot enable it\n");
1883                         LEAVE();
1884                         return -EINVAL;
1885                 }
1886                 assoc_req->wep_tx_keyidx = index;
1887         }
1888
1889         assoc_req->secinfo.WEPstatus = wlan802_11WEPenabled;
1890
1891         LEAVE();
1892         return 0;
1893 }
1894
1895 static int validate_key_index(u16 def_index, u16 raw_index,
1896                               u16 *out_index, u16 *is_default)
1897 {
1898         if (!out_index || !is_default)
1899                 return -EINVAL;
1900
1901         /* Verify index if present, otherwise use default TX key index */
1902         if (raw_index > 0) {
1903                 if (raw_index > 4)
1904                         return -EINVAL;
1905                 *out_index = raw_index - 1;
1906         } else {
1907                 *out_index = def_index;
1908                 *is_default = 1;
1909         }
1910         return 0;
1911 }
1912
1913 static void disable_wep(struct assoc_request *assoc_req)
1914 {
1915         int i;
1916
1917         /* Set Open System auth mode */
1918         assoc_req->secinfo.authmode = wlan802_11authmodeopen;
1919
1920         /* Clear WEP keys and mark WEP as disabled */
1921         assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
1922         for (i = 0; i < 4; i++)
1923                 assoc_req->wep_keys[i].len = 0;
1924
1925         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1926         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1927 }
1928
1929 /**
1930  *  @brief Set Encryption key
1931  *
1932  *  @param dev                  A pointer to net_device structure
1933  *  @param info                 A pointer to iw_request_info structure
1934  *  @param vwrq                 A pointer to iw_param structure
1935  *  @param extra                A pointer to extra data buf
1936  *  @return                     0 --success, otherwise fail
1937  */
1938 static int wlan_set_encode(struct net_device *dev,
1939                     struct iw_request_info *info,
1940                     struct iw_point *dwrq, char *extra)
1941 {
1942         int ret = 0;
1943         wlan_private *priv = dev->priv;
1944         wlan_adapter *adapter = priv->adapter;
1945         struct assoc_request * assoc_req;
1946         u16 is_default = 0, index = 0, set_tx_key = 0;
1947
1948         ENTER();
1949
1950         mutex_lock(&adapter->lock);
1951         assoc_req = wlan_get_association_request(adapter);
1952         if (!assoc_req) {
1953                 ret = -ENOMEM;
1954                 goto out;
1955         }
1956
1957         if (dwrq->flags & IW_ENCODE_DISABLED) {
1958                 disable_wep (assoc_req);
1959                 goto out;
1960         }
1961
1962         ret = validate_key_index(assoc_req->wep_tx_keyidx,
1963                                  (dwrq->flags & IW_ENCODE_INDEX),
1964                                  &index, &is_default);
1965         if (ret) {
1966                 ret = -EINVAL;
1967                 goto out;
1968         }
1969
1970         /* If WEP isn't enabled, or if there is no key data but a valid
1971          * index, set the TX key.
1972          */
1973         if ((assoc_req->secinfo.WEPstatus != wlan802_11WEPenabled)
1974             || (dwrq->length == 0 && !is_default))
1975                 set_tx_key = 1;
1976
1977         ret = wlan_set_wep_key(assoc_req, extra, dwrq->length, index, set_tx_key);
1978         if (ret)
1979                 goto out;
1980
1981         if (dwrq->length)
1982                 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1983         if (set_tx_key)
1984                 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
1985
1986         if (dwrq->flags & IW_ENCODE_RESTRICTED) {
1987                 assoc_req->secinfo.authmode = wlan802_11authmodeshared;
1988         } else if (dwrq->flags & IW_ENCODE_OPEN) {
1989                 assoc_req->secinfo.authmode = wlan802_11authmodeopen;
1990         }
1991
1992 out:
1993         if (ret == 0) {
1994                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1995                 wlan_postpone_association_work(priv);
1996         } else {
1997                 wlan_cancel_association_work(priv);
1998         }
1999         mutex_unlock(&adapter->lock);
2000
2001         LEAVE();
2002         return ret;
2003 }
2004
2005 /**
2006  *  @brief Get Extended Encryption key (WPA/802.1x and WEP)
2007  *
2008  *  @param dev                  A pointer to net_device structure
2009  *  @param info                 A pointer to iw_request_info structure
2010  *  @param vwrq                 A pointer to iw_param structure
2011  *  @param extra                A pointer to extra data buf
2012  *  @return                     0 on success, otherwise failure
2013  */
2014 static int wlan_get_encodeext(struct net_device *dev,
2015                               struct iw_request_info *info,
2016                               struct iw_point *dwrq,
2017                               char *extra)
2018 {
2019         int ret = -EINVAL;
2020         wlan_private *priv = dev->priv;
2021         wlan_adapter *adapter = priv->adapter;
2022         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2023         int index, max_key_len;
2024
2025         ENTER();
2026
2027         max_key_len = dwrq->length - sizeof(*ext);
2028         if (max_key_len < 0)
2029                 goto out;
2030
2031         index = dwrq->flags & IW_ENCODE_INDEX;
2032         if (index) {
2033                 if (index < 1 || index > 4)
2034                         goto out;
2035                 index--;
2036         } else {
2037                 index = adapter->wep_tx_keyidx;
2038         }
2039
2040         if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
2041             ext->alg != IW_ENCODE_ALG_WEP) {
2042                 if (index != 0 || adapter->inframode != wlan802_11infrastructure)
2043                         goto out;
2044         }
2045
2046         dwrq->flags = index + 1;
2047         memset(ext, 0, sizeof(*ext));
2048
2049         if ((adapter->secinfo.WEPstatus == wlan802_11WEPdisabled)
2050             && !adapter->secinfo.WPAenabled && !adapter->secinfo.WPA2enabled) {
2051                 ext->alg = IW_ENCODE_ALG_NONE;
2052                 ext->key_len = 0;
2053                 dwrq->flags |= IW_ENCODE_DISABLED;
2054         } else {
2055                 u8 *key = NULL;
2056
2057                 if ((adapter->secinfo.WEPstatus == wlan802_11WEPenabled)
2058                     && !adapter->secinfo.WPAenabled
2059                     && !adapter->secinfo.WPA2enabled) {
2060                         ext->alg = IW_ENCODE_ALG_WEP;
2061                         ext->key_len = adapter->wep_keys[index].len;
2062                         key = &adapter->wep_keys[index].key[0];
2063                 } else if ((adapter->secinfo.WEPstatus == wlan802_11WEPdisabled) &&
2064                            (adapter->secinfo.WPAenabled ||
2065                             adapter->secinfo.WPA2enabled)) {
2066                         /* WPA */
2067                         ext->alg = IW_ENCODE_ALG_TKIP;
2068                         ext->key_len = 0;
2069                 } else {
2070                         goto out;
2071                 }
2072
2073                 if (ext->key_len > max_key_len) {
2074                         ret = -E2BIG;
2075                         goto out;
2076                 }
2077
2078                 if (ext->key_len)
2079                         memcpy(ext->key, key, ext->key_len);
2080                 else
2081                         dwrq->flags |= IW_ENCODE_NOKEY;
2082                 dwrq->flags |= IW_ENCODE_ENABLED;
2083         }
2084         ret = 0;
2085
2086 out:
2087         LEAVE();
2088         return ret;
2089 }
2090
2091 /**
2092  *  @brief Set Encryption key Extended (WPA/802.1x and WEP)
2093  *
2094  *  @param dev                  A pointer to net_device structure
2095  *  @param info                 A pointer to iw_request_info structure
2096  *  @param vwrq                 A pointer to iw_param structure
2097  *  @param extra                A pointer to extra data buf
2098  *  @return                     0 --success, otherwise fail
2099  */
2100 static int wlan_set_encodeext(struct net_device *dev,
2101                               struct iw_request_info *info,
2102                               struct iw_point *dwrq,
2103                               char *extra)
2104 {
2105         int ret = 0;
2106         wlan_private *priv = dev->priv;
2107         wlan_adapter *adapter = priv->adapter;
2108         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2109         int alg = ext->alg;
2110         struct assoc_request * assoc_req;
2111
2112         ENTER();
2113
2114         mutex_lock(&adapter->lock);
2115         assoc_req = wlan_get_association_request(adapter);
2116         if (!assoc_req) {
2117                 ret = -ENOMEM;
2118                 goto out;
2119         }
2120
2121         if ((alg == IW_ENCODE_ALG_NONE) || (dwrq->flags & IW_ENCODE_DISABLED)) {
2122                 disable_wep (assoc_req);
2123         } else if (alg == IW_ENCODE_ALG_WEP) {
2124                 u16 is_default = 0, index, set_tx_key = 0;
2125
2126                 ret = validate_key_index(assoc_req->wep_tx_keyidx,
2127                                          (dwrq->flags & IW_ENCODE_INDEX),
2128                                          &index, &is_default);
2129                 if (ret)
2130                         goto out;
2131
2132                 /* If WEP isn't enabled, or if there is no key data but a valid
2133                  * index, or if the set-TX-key flag was passed, set the TX key.
2134                  */
2135                 if ((assoc_req->secinfo.WEPstatus != wlan802_11WEPenabled)
2136                     || (dwrq->length == 0 && !is_default)
2137                     || (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY))
2138                         set_tx_key = 1;
2139
2140                 /* Copy key to driver */
2141                 ret = wlan_set_wep_key (assoc_req, ext->key, ext->key_len, index,
2142                                         set_tx_key);
2143                 if (ret)
2144                         goto out;
2145
2146                 if (dwrq->flags & IW_ENCODE_RESTRICTED) {
2147                         assoc_req->secinfo.authmode =
2148                             wlan802_11authmodeshared;
2149                 } else if (dwrq->flags & IW_ENCODE_OPEN) {
2150                         assoc_req->secinfo.authmode =
2151                             wlan802_11authmodeopen;
2152                 }
2153
2154                 /* Mark the various WEP bits as modified */
2155                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2156                 if (dwrq->length)
2157                         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
2158                 if (set_tx_key)
2159                         set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
2160
2161         } else if ((alg == IW_ENCODE_ALG_TKIP) || (alg == IW_ENCODE_ALG_CCMP)) {
2162                 struct WLAN_802_11_KEY * pkey;
2163
2164                 /* validate key length */
2165                 if (((alg == IW_ENCODE_ALG_TKIP)
2166                         && (ext->key_len != KEY_LEN_WPA_TKIP))
2167                     || ((alg == IW_ENCODE_ALG_CCMP)
2168                         && (ext->key_len != KEY_LEN_WPA_AES))) {
2169                                 lbs_pr_debug(1, "Invalid size %d for key of alg"
2170                                        "type %d.\n",
2171                                        ext->key_len,
2172                                        alg);
2173                                 ret = -EINVAL;
2174                                 goto out;
2175                 }
2176
2177                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
2178                         pkey = &assoc_req->wpa_mcast_key;
2179                 else
2180                         pkey = &assoc_req->wpa_unicast_key;
2181
2182                 memset(pkey, 0, sizeof (struct WLAN_802_11_KEY));
2183                 memcpy(pkey->key, ext->key, ext->key_len);
2184                 pkey->len = ext->key_len;
2185                 pkey->flags = KEY_INFO_WPA_ENABLED;
2186
2187                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
2188                         pkey->flags |= KEY_INFO_WPA_MCAST;
2189                         set_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
2190                 } else {
2191                         pkey->flags |= KEY_INFO_WPA_UNICAST;
2192                         set_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
2193                 }
2194
2195                 if (alg == IW_ENCODE_ALG_TKIP)
2196                         pkey->type = KEY_TYPE_ID_TKIP;
2197                 else if (alg == IW_ENCODE_ALG_CCMP)
2198                         pkey->type = KEY_TYPE_ID_AES;
2199
2200                 /* If WPA isn't enabled yet, do that now */
2201                 if (   assoc_req->secinfo.WPAenabled == 0
2202                     && assoc_req->secinfo.WPA2enabled == 0) {
2203                         assoc_req->secinfo.WPAenabled = 1;
2204                         assoc_req->secinfo.WPA2enabled = 1;
2205                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2206                 }
2207
2208                 disable_wep (assoc_req);
2209         }
2210
2211 out:
2212         if (ret == 0) {
2213                 wlan_postpone_association_work(priv);
2214         } else {
2215                 wlan_cancel_association_work(priv);
2216         }
2217         mutex_unlock(&adapter->lock);
2218
2219         LEAVE();
2220         return ret;
2221 }
2222
2223
2224 static int wlan_set_genie(struct net_device *dev,
2225                           struct iw_request_info *info,
2226                           struct iw_point *dwrq,
2227                           char *extra)
2228 {
2229         wlan_private *priv = dev->priv;
2230         wlan_adapter *adapter = priv->adapter;
2231         int ret = 0;
2232         struct assoc_request * assoc_req;
2233
2234         ENTER();
2235
2236         mutex_lock(&adapter->lock);
2237         assoc_req = wlan_get_association_request(adapter);
2238         if (!assoc_req) {
2239                 ret = -ENOMEM;
2240                 goto out;
2241         }
2242
2243         if (dwrq->length > MAX_WPA_IE_LEN ||
2244             (dwrq->length && extra == NULL)) {
2245                 ret = -EINVAL;
2246                 goto out;
2247         }
2248
2249         if (dwrq->length) {
2250                 memcpy(&assoc_req->wpa_ie[0], extra, dwrq->length);
2251                 assoc_req->wpa_ie_len = dwrq->length;
2252         } else {
2253                 memset(&assoc_req->wpa_ie[0], 0, sizeof(adapter->wpa_ie));
2254                 assoc_req->wpa_ie_len = 0;
2255         }
2256
2257 out:
2258         if (ret == 0) {
2259                 set_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags);
2260                 wlan_postpone_association_work(priv);
2261         } else {
2262                 wlan_cancel_association_work(priv);
2263         }
2264         mutex_unlock(&adapter->lock);
2265
2266         LEAVE();
2267         return ret;
2268 }
2269
2270 static int wlan_get_genie(struct net_device *dev,
2271                           struct iw_request_info *info,
2272                           struct iw_point *dwrq,
2273                           char *extra)
2274 {
2275         wlan_private *priv = dev->priv;
2276         wlan_adapter *adapter = priv->adapter;
2277
2278         ENTER();
2279
2280         if (adapter->wpa_ie_len == 0) {
2281                 dwrq->length = 0;
2282                 LEAVE();
2283                 return 0;
2284         }
2285
2286         if (dwrq->length < adapter->wpa_ie_len) {
2287                 LEAVE();
2288                 return -E2BIG;
2289         }
2290
2291         dwrq->length = adapter->wpa_ie_len;
2292         memcpy(extra, &adapter->wpa_ie[0], adapter->wpa_ie_len);
2293
2294         LEAVE();
2295         return 0;
2296 }
2297
2298
2299 static int wlan_set_auth(struct net_device *dev,
2300                          struct iw_request_info *info,
2301                          struct iw_param *dwrq,
2302                          char *extra)
2303 {
2304         wlan_private *priv = dev->priv;
2305         wlan_adapter *adapter = priv->adapter;
2306         struct assoc_request * assoc_req;
2307         int ret = 0;
2308         int updated = 0;
2309
2310         ENTER();
2311
2312         mutex_lock(&adapter->lock);
2313         assoc_req = wlan_get_association_request(adapter);
2314         if (!assoc_req) {
2315                 ret = -ENOMEM;
2316                 goto out;
2317         }
2318
2319         switch (dwrq->flags & IW_AUTH_INDEX) {
2320         case IW_AUTH_TKIP_COUNTERMEASURES:
2321         case IW_AUTH_CIPHER_PAIRWISE:
2322         case IW_AUTH_CIPHER_GROUP:
2323         case IW_AUTH_KEY_MGMT:
2324                 /*
2325                  * libertas does not use these parameters
2326                  */
2327                 break;
2328
2329         case IW_AUTH_WPA_VERSION:
2330                 if (dwrq->value & IW_AUTH_WPA_VERSION_DISABLED) {
2331                         assoc_req->secinfo.WPAenabled = 0;
2332                         assoc_req->secinfo.WPA2enabled = 0;
2333                 }
2334                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA) {
2335                         assoc_req->secinfo.WPAenabled = 1;
2336                         assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
2337                         assoc_req->secinfo.authmode =
2338                             wlan802_11authmodeopen;
2339                 }
2340                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA2) {
2341                         assoc_req->secinfo.WPA2enabled = 1;
2342                         assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
2343                         assoc_req->secinfo.authmode =
2344                             wlan802_11authmodeopen;
2345                 }
2346                 updated = 1;
2347                 break;
2348
2349         case IW_AUTH_DROP_UNENCRYPTED:
2350                 if (dwrq->value) {
2351                         adapter->currentpacketfilter |=
2352                             cmd_act_mac_strict_protection_enable;
2353                 } else {
2354                         adapter->currentpacketfilter &=
2355                             ~cmd_act_mac_strict_protection_enable;
2356                 }
2357                 updated = 1;
2358                 break;
2359
2360         case IW_AUTH_80211_AUTH_ALG:
2361                 if (dwrq->value & IW_AUTH_ALG_SHARED_KEY) {
2362                         assoc_req->secinfo.authmode =
2363                             wlan802_11authmodeshared;
2364                 } else if (dwrq->value & IW_AUTH_ALG_OPEN_SYSTEM) {
2365                         assoc_req->secinfo.authmode =
2366                             wlan802_11authmodeopen;
2367                 } else if (dwrq->value & IW_AUTH_ALG_LEAP) {
2368                         assoc_req->secinfo.authmode =
2369                             wlan802_11authmodenetworkEAP;
2370                 } else {
2371                         ret = -EINVAL;
2372                 }
2373                 updated = 1;
2374                 break;
2375
2376         case IW_AUTH_WPA_ENABLED:
2377                 if (dwrq->value) {
2378                         if (!assoc_req->secinfo.WPAenabled &&
2379                             !assoc_req->secinfo.WPA2enabled) {
2380                                 assoc_req->secinfo.WPAenabled = 1;
2381                                 assoc_req->secinfo.WPA2enabled = 1;
2382                                 assoc_req->secinfo.WEPstatus = wlan802_11WEPdisabled;
2383                                 assoc_req->secinfo.authmode =
2384                                     wlan802_11authmodeopen;
2385                         }
2386                 } else {
2387                         assoc_req->secinfo.WPAenabled = 0;
2388                         assoc_req->secinfo.WPA2enabled = 0;
2389                 }
2390                 updated = 1;
2391                 break;
2392
2393         default:
2394                 ret = -EOPNOTSUPP;
2395                 break;
2396         }
2397
2398 out:
2399         if (ret == 0) {
2400                 if (updated)
2401                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
2402                 wlan_postpone_association_work(priv);
2403         } else if (ret != -EOPNOTSUPP) {
2404                 wlan_cancel_association_work(priv);
2405         }
2406         mutex_unlock(&adapter->lock);
2407
2408         LEAVE();
2409         return ret;
2410 }
2411
2412 static int wlan_get_auth(struct net_device *dev,
2413                          struct iw_request_info *info,
2414                          struct iw_param *dwrq,
2415                          char *extra)
2416 {
2417         wlan_private *priv = dev->priv;
2418         wlan_adapter *adapter = priv->adapter;
2419
2420         ENTER();
2421
2422         switch (dwrq->flags & IW_AUTH_INDEX) {
2423         case IW_AUTH_WPA_VERSION:
2424                 dwrq->value = 0;
2425                 if (adapter->secinfo.WPAenabled)
2426                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA;
2427                 if (adapter->secinfo.WPA2enabled)
2428                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA2;
2429                 if (!dwrq->value)
2430                         dwrq->value |= IW_AUTH_WPA_VERSION_DISABLED;
2431                 break;
2432
2433         case IW_AUTH_DROP_UNENCRYPTED:
2434                 dwrq->value = 0;
2435                 if (adapter->currentpacketfilter &
2436                     cmd_act_mac_strict_protection_enable)
2437                         dwrq->value = 1;
2438                 break;
2439
2440         case IW_AUTH_80211_AUTH_ALG:
2441                 switch (adapter->secinfo.authmode) {
2442                 case wlan802_11authmodeshared:
2443                         dwrq->value = IW_AUTH_ALG_SHARED_KEY;
2444                         break;
2445                 case wlan802_11authmodeopen:
2446                         dwrq->value = IW_AUTH_ALG_OPEN_SYSTEM;
2447                         break;
2448                 case wlan802_11authmodenetworkEAP:
2449                         dwrq->value = IW_AUTH_ALG_LEAP;
2450                         break;
2451                 default:
2452                         break;
2453                 }
2454                 break;
2455
2456         case IW_AUTH_WPA_ENABLED:
2457                 if (adapter->secinfo.WPAenabled && adapter->secinfo.WPA2enabled)
2458                         dwrq->value = 1;
2459                 break;
2460
2461         default:
2462                 LEAVE();
2463                 return -EOPNOTSUPP;
2464         }
2465
2466         LEAVE();
2467         return 0;
2468 }
2469
2470
2471 static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
2472                    struct iw_param *vwrq, char *extra)
2473 {
2474         int ret = 0;
2475         wlan_private *priv = dev->priv;
2476         wlan_adapter *adapter = priv->adapter;
2477
2478         u16 dbm;
2479
2480         ENTER();
2481
2482         if (vwrq->disabled) {
2483                 wlan_radio_ioctl(priv, RADIO_OFF);
2484                 return 0;
2485         }
2486
2487         adapter->preamble = cmd_type_auto_preamble;
2488
2489         wlan_radio_ioctl(priv, RADIO_ON);
2490
2491         if ((vwrq->flags & IW_TXPOW_TYPE) == IW_TXPOW_MWATT) {
2492                 dbm = (u16) mw_to_dbm(vwrq->value);
2493         } else
2494                 dbm = (u16) vwrq->value;
2495
2496         /* auto tx power control */
2497
2498         if (vwrq->fixed == 0)
2499                 dbm = 0xffff;
2500
2501         lbs_pr_debug(1, "<1>TXPOWER SET %d dbm.\n", dbm);
2502
2503         ret = libertas_prepare_and_send_command(priv,
2504                                     cmd_802_11_rf_tx_power,
2505                                     cmd_act_tx_power_opt_set_low,
2506                                     cmd_option_waitforrsp, 0, (void *)&dbm);
2507
2508         LEAVE();
2509         return ret;
2510 }
2511
2512 static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
2513                    struct iw_point *dwrq, char *extra)
2514 {
2515         wlan_private *priv = dev->priv;
2516         wlan_adapter *adapter = priv->adapter;
2517
2518         ENTER();
2519         /*
2520          * Note : if dwrq->flags != 0, we should get the relevant SSID from
2521          * the SSID list...
2522          */
2523
2524         /*
2525          * Get the current SSID
2526          */
2527         if (adapter->connect_status == libertas_connected) {
2528                 memcpy(extra, adapter->curbssparams.ssid.ssid,
2529                        adapter->curbssparams.ssid.ssidlength);
2530                 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2531         } else {
2532                 memset(extra, 0, 32);
2533                 extra[adapter->curbssparams.ssid.ssidlength] = '\0';
2534         }
2535         /*
2536          * If none, we may want to get the one that was set
2537          */
2538
2539         /* To make the driver backward compatible with WPA supplicant v0.2.4 */
2540         if (dwrq->length == 32) /* check with WPA supplicant buffer size */
2541                 dwrq->length = min_t(size_t, adapter->curbssparams.ssid.ssidlength,
2542                                    IW_ESSID_MAX_SIZE);
2543         else
2544                 dwrq->length = adapter->curbssparams.ssid.ssidlength + 1;
2545
2546         dwrq->flags = 1;        /* active */
2547
2548         LEAVE();
2549         return 0;
2550 }
2551
2552 static int wlan_set_essid(struct net_device *dev, struct iw_request_info *info,
2553                    struct iw_point *dwrq, char *extra)
2554 {
2555         wlan_private *priv = dev->priv;
2556         wlan_adapter *adapter = priv->adapter;
2557         int ret = 0;
2558         struct WLAN_802_11_SSID ssid;
2559         struct assoc_request * assoc_req;
2560         int ssid_len = dwrq->length;
2561
2562         ENTER();
2563
2564         /*
2565          * WE-20 and earlier NULL pad the end of the SSID and increment
2566          * SSID length so it can be used like a string.  WE-21 and later don't,
2567          * but some userspace tools aren't able to cope with the change.
2568          */
2569         if ((ssid_len > 0) && (extra[ssid_len - 1] == '\0'))
2570                 ssid_len--;
2571
2572         /* Check the size of the string */
2573         if (ssid_len > IW_ESSID_MAX_SIZE) {
2574                 ret = -E2BIG;
2575                 goto out;
2576         }
2577
2578         memset(&ssid, 0, sizeof(struct WLAN_802_11_SSID));
2579
2580         if (!dwrq->flags || !ssid_len) {
2581                 /* "any" SSID requested; leave SSID blank */
2582         } else {
2583                 /* Specific SSID requested */
2584                 memcpy(&ssid.ssid, extra, ssid_len);
2585                 ssid.ssidlength = ssid_len;
2586         }
2587
2588         lbs_pr_debug(1, "Requested new SSID = %s\n",
2589                (ssid.ssidlength > 0) ? (char *)ssid.ssid : "any");
2590
2591 out:
2592         mutex_lock(&adapter->lock);
2593         if (ret == 0) {
2594                 /* Get or create the current association request */
2595                 assoc_req = wlan_get_association_request(adapter);
2596                 if (!assoc_req) {
2597                         ret = -ENOMEM;
2598                 } else {
2599                         /* Copy the SSID to the association request */
2600                         memcpy(&assoc_req->ssid, &ssid, sizeof(struct WLAN_802_11_SSID));
2601                         set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
2602                         wlan_postpone_association_work(priv);
2603                 }
2604         }
2605
2606         /* Cancel the association request if there was an error */
2607         if (ret != 0) {
2608                 wlan_cancel_association_work(priv);
2609         }
2610
2611         mutex_unlock(&adapter->lock);
2612
2613         LEAVE();
2614         return ret;
2615 }
2616
2617 /**
2618  *  @brief Connect to the AP or Ad-hoc Network with specific bssid
2619  *
2620  *  @param dev          A pointer to net_device structure
2621  *  @param info         A pointer to iw_request_info structure
2622  *  @param awrq         A pointer to iw_param structure
2623  *  @param extra        A pointer to extra data buf
2624  *  @return             0 --success, otherwise fail
2625  */
2626 static int wlan_set_wap(struct net_device *dev, struct iw_request_info *info,
2627                  struct sockaddr *awrq, char *extra)
2628 {
2629         wlan_private *priv = dev->priv;
2630         wlan_adapter *adapter = priv->adapter;
2631         struct assoc_request * assoc_req;
2632         int ret = 0;
2633
2634         ENTER();
2635
2636         if (awrq->sa_family != ARPHRD_ETHER)
2637                 return -EINVAL;
2638
2639         lbs_pr_debug(1, "ASSOC: WAP: sa_data: " MAC_FMT "\n", MAC_ARG(awrq->sa_data));
2640
2641         mutex_lock(&adapter->lock);
2642
2643         /* Get or create the current association request */
2644         assoc_req = wlan_get_association_request(adapter);
2645         if (!assoc_req) {
2646                 wlan_cancel_association_work(priv);
2647                 ret = -ENOMEM;
2648         } else {
2649                 /* Copy the BSSID to the association request */
2650                 memcpy(&assoc_req->bssid, awrq->sa_data, ETH_ALEN);
2651                 set_bit(ASSOC_FLAG_BSSID, &assoc_req->flags);
2652                 wlan_postpone_association_work(priv);
2653         }
2654
2655         mutex_unlock(&adapter->lock);
2656
2657         return ret;
2658 }
2659
2660 void libertas_get_fwversion(wlan_adapter * adapter, char *fwversion, int maxlen)
2661 {
2662         union {
2663                 u32 l;
2664                 u8 c[4];
2665         } ver;
2666         char fwver[32];
2667
2668         mutex_lock(&adapter->lock);
2669         ver.l = adapter->fwreleasenumber;
2670         mutex_unlock(&adapter->lock);
2671
2672         if (ver.c[3] == 0)
2673                 sprintf(fwver, "%u.%u.%u", ver.c[2], ver.c[1], ver.c[0]);
2674         else
2675                 sprintf(fwver, "%u.%u.%u.p%u",
2676                         ver.c[2], ver.c[1], ver.c[0], ver.c[3]);
2677
2678         snprintf(fwversion, maxlen, fwver);
2679 }
2680
2681
2682 /*
2683  * iwconfig settable callbacks
2684  */
2685 static const iw_handler wlan_handler[] = {
2686         (iw_handler) NULL,      /* SIOCSIWCOMMIT */
2687         (iw_handler) wlan_get_name,     /* SIOCGIWNAME */
2688         (iw_handler) NULL,      /* SIOCSIWNWID */
2689         (iw_handler) NULL,      /* SIOCGIWNWID */
2690         (iw_handler) wlan_set_freq,     /* SIOCSIWFREQ */
2691         (iw_handler) wlan_get_freq,     /* SIOCGIWFREQ */
2692         (iw_handler) wlan_set_mode,     /* SIOCSIWMODE */
2693         (iw_handler) wlan_get_mode,     /* SIOCGIWMODE */
2694         (iw_handler) NULL,      /* SIOCSIWSENS */
2695         (iw_handler) NULL,      /* SIOCGIWSENS */
2696         (iw_handler) NULL,      /* SIOCSIWRANGE */
2697         (iw_handler) wlan_get_range,    /* SIOCGIWRANGE */
2698         (iw_handler) NULL,      /* SIOCSIWPRIV */
2699         (iw_handler) NULL,      /* SIOCGIWPRIV */
2700         (iw_handler) NULL,      /* SIOCSIWSTATS */
2701         (iw_handler) NULL,      /* SIOCGIWSTATS */
2702         iw_handler_set_spy,     /* SIOCSIWSPY */
2703         iw_handler_get_spy,     /* SIOCGIWSPY */
2704         iw_handler_set_thrspy,  /* SIOCSIWTHRSPY */
2705         iw_handler_get_thrspy,  /* SIOCGIWTHRSPY */
2706         (iw_handler) wlan_set_wap,      /* SIOCSIWAP */
2707         (iw_handler) wlan_get_wap,      /* SIOCGIWAP */
2708         (iw_handler) NULL,      /* SIOCSIWMLME */
2709         (iw_handler) NULL,      /* SIOCGIWAPLIST - deprecated */
2710         (iw_handler) libertas_set_scan, /* SIOCSIWSCAN */
2711         (iw_handler) libertas_get_scan, /* SIOCGIWSCAN */
2712         (iw_handler) wlan_set_essid,    /* SIOCSIWESSID */
2713         (iw_handler) wlan_get_essid,    /* SIOCGIWESSID */
2714         (iw_handler) wlan_set_nick,     /* SIOCSIWNICKN */
2715         (iw_handler) wlan_get_nick,     /* SIOCGIWNICKN */
2716         (iw_handler) NULL,      /* -- hole -- */
2717         (iw_handler) NULL,      /* -- hole -- */
2718         (iw_handler) wlan_set_rate,     /* SIOCSIWRATE */
2719         (iw_handler) wlan_get_rate,     /* SIOCGIWRATE */
2720         (iw_handler) wlan_set_rts,      /* SIOCSIWRTS */
2721         (iw_handler) wlan_get_rts,      /* SIOCGIWRTS */
2722         (iw_handler) wlan_set_frag,     /* SIOCSIWFRAG */
2723         (iw_handler) wlan_get_frag,     /* SIOCGIWFRAG */
2724         (iw_handler) wlan_set_txpow,    /* SIOCSIWTXPOW */
2725         (iw_handler) wlan_get_txpow,    /* SIOCGIWTXPOW */
2726         (iw_handler) wlan_set_retry,    /* SIOCSIWRETRY */
2727         (iw_handler) wlan_get_retry,    /* SIOCGIWRETRY */
2728         (iw_handler) wlan_set_encode,   /* SIOCSIWENCODE */
2729         (iw_handler) wlan_get_encode,   /* SIOCGIWENCODE */
2730         (iw_handler) wlan_set_power,    /* SIOCSIWPOWER */
2731         (iw_handler) wlan_get_power,    /* SIOCGIWPOWER */
2732         (iw_handler) NULL,      /* -- hole -- */
2733         (iw_handler) NULL,      /* -- hole -- */
2734         (iw_handler) wlan_set_genie,    /* SIOCSIWGENIE */
2735         (iw_handler) wlan_get_genie,    /* SIOCGIWGENIE */
2736         (iw_handler) wlan_set_auth,     /* SIOCSIWAUTH */
2737         (iw_handler) wlan_get_auth,     /* SIOCGIWAUTH */
2738         (iw_handler) wlan_set_encodeext,/* SIOCSIWENCODEEXT */
2739         (iw_handler) wlan_get_encodeext,/* SIOCGIWENCODEEXT */
2740         (iw_handler) NULL,              /* SIOCSIWPMKSA */
2741 };
2742
2743 struct iw_handler_def libertas_handler_def = {
2744         .num_standard   = sizeof(wlan_handler) / sizeof(iw_handler),
2745         .num_private    = sizeof(wlan_private_handler) / sizeof(iw_handler),
2746         .num_private_args = sizeof(wlan_private_args) /
2747                 sizeof(struct iw_priv_args),
2748         .standard       = (iw_handler *) wlan_handler,
2749         .private        = (iw_handler *) wlan_private_handler,
2750         .private_args   = (struct iw_priv_args *)wlan_private_args,
2751         .get_wireless_stats = wlan_get_wireless_stats,
2752 };