git.oblomov.eu Git - 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 "wext.h"
  21 #include "assoc.h"
  22
  23
  24 /**
  25  *  @brief Convert mw value to dbm value
  26  *
  27  *  @param mw      the value of mw
  28  *  @return        the value of dbm
  29  */
  30 static int mw_to_dbm(int mw)
  31 {
  32         if (mw < 2)
  33                 return 0;
  34         else if (mw < 3)
  35                 return 3;
  36         else if (mw < 4)
  37                 return 5;
  38         else if (mw < 6)
  39                 return 7;
  40         else if (mw < 7)
  41                 return 8;
  42         else if (mw < 8)
  43                 return 9;
  44         else if (mw < 10)
  45                 return 10;
  46         else if (mw < 13)
  47                 return 11;
  48         else if (mw < 16)
  49                 return 12;
  50         else if (mw < 20)
  51                 return 13;
  52         else if (mw < 25)
  53                 return 14;
  54         else if (mw < 32)
  55                 return 15;
  56         else if (mw < 40)
  57                 return 16;
  58         else if (mw < 50)
  59                 return 17;
  60         else if (mw < 63)
  61                 return 18;
  62         else if (mw < 79)
  63                 return 19;
  64         else if (mw < 100)
  65                 return 20;
  66         else
  67                 return 21;
  68 }
  69
  70 /**
  71  *  @brief Find the channel frequency power info with specific channel
  72  *
  73  *  @param adapter      A pointer to wlan_adapter structure
  74  *  @param band         it can be BAND_A, BAND_G or BAND_B
  75  *  @param channel      the channel for looking
  76  *  @return             A pointer to struct chan_freq_power structure or NULL if not find.
  77  */
  78 struct chan_freq_power *libertas_find_cfp_by_band_and_channel(wlan_adapter * adapter,
  79                                                  u8 band, u16 channel)
  80 {
  81         struct chan_freq_power *cfp = NULL;
  82         struct region_channel *rc;
  83         int count = sizeof(adapter->region_channel) /
  84             sizeof(adapter->region_channel[0]);
  85         int i, j;
  86
  87         for (j = 0; !cfp && (j < count); j++) {
  88                 rc = &adapter->region_channel[j];
  89
  90                 if (adapter->enable11d)
  91                         rc = &adapter->universal_channel[j];
  92                 if (!rc->valid || !rc->CFP)
  93                         continue;
  94                 if (rc->band != band)
  95                         continue;
  96                 for (i = 0; i < rc->nrcfp; i++) {
  97                         if (rc->CFP[i].channel == channel) {
  98                                 cfp = &rc->CFP[i];
  99                                 break;
 100                         }
 101                 }
 102         }
 103
 104         if (!cfp && channel)
 105                 lbs_deb_wext("libertas_find_cfp_by_band_and_channel: can't find "
 106                        "cfp by band %d / channel %d\n", band, channel);
 107
 108         return cfp;
 109 }
 110
 111 /**
 112  *  @brief Find the channel frequency power info with specific frequency
 113  *
 114  *  @param adapter      A pointer to wlan_adapter structure
 115  *  @param band         it can be BAND_A, BAND_G or BAND_B
 116  *  @param freq         the frequency for looking
 117  *  @return             A pointer to struct chan_freq_power structure or NULL if not find.
 118  */
 119 static struct chan_freq_power *find_cfp_by_band_and_freq(wlan_adapter * adapter,
 120                                                      u8 band, u32 freq)
 121 {
 122         struct chan_freq_power *cfp = NULL;
 123         struct region_channel *rc;
 124         int count = sizeof(adapter->region_channel) /
 125             sizeof(adapter->region_channel[0]);
 126         int i, j;
 127
 128         for (j = 0; !cfp && (j < count); j++) {
 129                 rc = &adapter->region_channel[j];
 130
 131                 if (adapter->enable11d)
 132                         rc = &adapter->universal_channel[j];
 133                 if (!rc->valid || !rc->CFP)
 134                         continue;
 135                 if (rc->band != band)
 136                         continue;
 137                 for (i = 0; i < rc->nrcfp; i++) {
 138                         if (rc->CFP[i].freq == freq) {
 139                                 cfp = &rc->CFP[i];
 140                                 break;
 141                         }
 142                 }
 143         }
 144
 145         if (!cfp && freq)
 146                 lbs_deb_wext("find_cfp_by_band_and_freql: can't find cfp by "
 147                        "band %d / freq %d\n", band, freq);
 148
 149         return cfp;
 150 }
 151
 152
 153 /**
 154  *  @brief Set Radio On/OFF
 155  *
 156  *  @param priv                 A pointer to wlan_private structure
 157  *  @option                     Radio Option
 158  *  @return                     0 --success, otherwise fail
 159  */
 160 static int wlan_radio_ioctl(wlan_private * priv, u8 option)
 161 {
 162         int ret = 0;
 163         wlan_adapter *adapter = priv->adapter;
 164
 165         lbs_deb_enter(LBS_DEB_WEXT);
 166
 167         if (adapter->radioon != option) {
 168                 lbs_deb_wext("switching radio %s\n", option ? "on" : "off");
 169                 adapter->radioon = option;
 170
 171                 ret = libertas_prepare_and_send_command(priv,
 172                                             CMD_802_11_RADIO_CONTROL,
 173                                             CMD_ACT_SET,
 174                                             CMD_OPTION_WAITFORRSP, 0, NULL);
 175         }
 176
 177         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 178         return ret;
 179 }
 180
 181 /**
 182  *  @brief Copy active data rates based on adapter mode and status
 183  *
 184  *  @param adapter              A pointer to wlan_adapter structure
 185  *  @param rate                 The buf to return the active rates
 186  */
 187 static void copy_active_data_rates(wlan_adapter * adapter, u8 * rates)
 188 {
 189         lbs_deb_enter(LBS_DEB_WEXT);
 190
 191         if (adapter->connect_status != LIBERTAS_CONNECTED)
 192                 memcpy(rates, libertas_bg_rates, MAX_RATES);
 193         else
 194                 memcpy(rates, adapter->curbssparams.rates, MAX_RATES);
 195
 196         lbs_deb_leave(LBS_DEB_WEXT);
 197 }
 198
 199 static int wlan_get_name(struct net_device *dev, struct iw_request_info *info,
 200                          char *cwrq, char *extra)
 201 {
 202         const char *cp;
 203         char comm[6] = { "COMM-" };
 204         char mrvl[6] = { "MRVL-" };
 205         int cnt;
 206
 207         lbs_deb_enter(LBS_DEB_WEXT);
 208
 209         strcpy(cwrq, mrvl);
 210
 211         cp = strstr(libertas_driver_version, comm);
 212         if (cp == libertas_driver_version)      //skip leading "COMM-"
 213                 cp = libertas_driver_version + strlen(comm);
 214         else
 215                 cp = libertas_driver_version;
 216
 217         cnt = strlen(mrvl);
 218         cwrq += cnt;
 219         while (cnt < 16 && (*cp != '-')) {
 220                 *cwrq++ = toupper(*cp++);
 221                 cnt++;
 222         }
 223         *cwrq = '\0';
 224
 225         lbs_deb_leave(LBS_DEB_WEXT);
 226         return 0;
 227 }
 228
 229 static int wlan_get_freq(struct net_device *dev, struct iw_request_info *info,
 230                          struct iw_freq *fwrq, char *extra)
 231 {
 232         wlan_private *priv = dev->priv;
 233         wlan_adapter *adapter = priv->adapter;
 234         struct chan_freq_power *cfp;
 235
 236         lbs_deb_enter(LBS_DEB_WEXT);
 237
 238         cfp = libertas_find_cfp_by_band_and_channel(adapter, 0,
 239                                            adapter->curbssparams.channel);
 240
 241         if (!cfp) {
 242                 if (adapter->curbssparams.channel)
 243                         lbs_deb_wext("invalid channel %d\n",
 244                                adapter->curbssparams.channel);
 245                 return -EINVAL;
 246         }
 247
 248         fwrq->m = (long)cfp->freq * 100000;
 249         fwrq->e = 1;
 250
 251         lbs_deb_wext("freq %u\n", fwrq->m);
 252         lbs_deb_leave(LBS_DEB_WEXT);
 253         return 0;
 254 }
 255
 256 static int wlan_get_wap(struct net_device *dev, struct iw_request_info *info,
 257                         struct sockaddr *awrq, char *extra)
 258 {
 259         wlan_private *priv = dev->priv;
 260         wlan_adapter *adapter = priv->adapter;
 261
 262         lbs_deb_enter(LBS_DEB_WEXT);
 263
 264         if (adapter->connect_status == LIBERTAS_CONNECTED) {
 265                 memcpy(awrq->sa_data, adapter->curbssparams.bssid, ETH_ALEN);
 266         } else {
 267                 memset(awrq->sa_data, 0, ETH_ALEN);
 268         }
 269         awrq->sa_family = ARPHRD_ETHER;
 270
 271         lbs_deb_leave(LBS_DEB_WEXT);
 272         return 0;
 273 }
 274
 275 static int wlan_set_nick(struct net_device *dev, struct iw_request_info *info,
 276                          struct iw_point *dwrq, char *extra)
 277 {
 278         wlan_private *priv = dev->priv;
 279         wlan_adapter *adapter = priv->adapter;
 280
 281         lbs_deb_enter(LBS_DEB_WEXT);
 282
 283         /*
 284          * Check the size of the string
 285          */
 286
 287         if (dwrq->length > 16) {
 288                 return -E2BIG;
 289         }
 290
 291         mutex_lock(&adapter->lock);
 292         memset(adapter->nodename, 0, sizeof(adapter->nodename));
 293         memcpy(adapter->nodename, extra, dwrq->length);
 294         mutex_unlock(&adapter->lock);
 295
 296         lbs_deb_leave(LBS_DEB_WEXT);
 297         return 0;
 298 }
 299
 300 static int wlan_get_nick(struct net_device *dev, struct iw_request_info *info,
 301                          struct iw_point *dwrq, char *extra)
 302 {
 303         wlan_private *priv = dev->priv;
 304         wlan_adapter *adapter = priv->adapter;
 305
 306         lbs_deb_enter(LBS_DEB_WEXT);
 307
 308         /*
 309          * Get the Nick Name saved
 310          */
 311
 312         mutex_lock(&adapter->lock);
 313         strncpy(extra, adapter->nodename, 16);
 314         mutex_unlock(&adapter->lock);
 315
 316         extra[16] = '\0';
 317
 318         /*
 319          * If none, we may want to get the one that was set
 320          */
 321
 322         /*
 323          * Push it out !
 324          */
 325         dwrq->length = strlen(extra) + 1;
 326
 327         lbs_deb_leave(LBS_DEB_WEXT);
 328         return 0;
 329 }
 330
 331 static int mesh_get_nick(struct net_device *dev, struct iw_request_info *info,
 332                          struct iw_point *dwrq, char *extra)
 333 {
 334         wlan_private *priv = dev->priv;
 335         wlan_adapter *adapter = priv->adapter;
 336
 337         lbs_deb_enter(LBS_DEB_WEXT);
 338
 339         /* Use nickname to indicate that mesh is on */
 340
 341         if (adapter->connect_status == LIBERTAS_CONNECTED) {
 342                 strncpy(extra, "Mesh", 12);
 343                 extra[12] = '\0';
 344                 dwrq->length = strlen(extra) + 1;
 345         }
 346
 347         else {
 348                 extra[0] = '\0';
 349                 dwrq->length = 1 ;
 350         }
 351
 352         lbs_deb_leave(LBS_DEB_WEXT);
 353         return 0;
 354 }
 355 static int wlan_set_rts(struct net_device *dev, struct iw_request_info *info,
 356                         struct iw_param *vwrq, char *extra)
 357 {
 358         int ret = 0;
 359         wlan_private *priv = dev->priv;
 360         wlan_adapter *adapter = priv->adapter;
 361         u32 rthr = vwrq->value;
 362
 363         lbs_deb_enter(LBS_DEB_WEXT);
 364
 365         if (vwrq->disabled) {
 366                 adapter->rtsthsd = rthr = MRVDRV_RTS_MAX_VALUE;
 367         } else {
 368                 if (rthr < MRVDRV_RTS_MIN_VALUE || rthr > MRVDRV_RTS_MAX_VALUE)
 369                         return -EINVAL;
 370                 adapter->rtsthsd = rthr;
 371         }
 372
 373         ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
 374                                     CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
 375                                     OID_802_11_RTS_THRESHOLD, &rthr);
 376
 377         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 378         return ret;
 379 }
 380
 381 static int wlan_get_rts(struct net_device *dev, struct iw_request_info *info,
 382                         struct iw_param *vwrq, char *extra)
 383 {
 384         int ret = 0;
 385         wlan_private *priv = dev->priv;
 386         wlan_adapter *adapter = priv->adapter;
 387
 388         lbs_deb_enter(LBS_DEB_WEXT);
 389
 390         adapter->rtsthsd = 0;
 391         ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
 392                                     CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
 393                                     OID_802_11_RTS_THRESHOLD, NULL);
 394         if (ret)
 395                 goto out;
 396
 397         vwrq->value = adapter->rtsthsd;
 398         vwrq->disabled = ((vwrq->value < MRVDRV_RTS_MIN_VALUE)
 399                           || (vwrq->value > MRVDRV_RTS_MAX_VALUE));
 400         vwrq->fixed = 1;
 401
 402 out:
 403         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 404         return ret;
 405 }
 406
 407 static int wlan_set_frag(struct net_device *dev, struct iw_request_info *info,
 408                          struct iw_param *vwrq, char *extra)
 409 {
 410         int ret = 0;
 411         u32 fthr = vwrq->value;
 412         wlan_private *priv = dev->priv;
 413         wlan_adapter *adapter = priv->adapter;
 414
 415         lbs_deb_enter(LBS_DEB_WEXT);
 416
 417         if (vwrq->disabled) {
 418                 adapter->fragthsd = fthr = MRVDRV_FRAG_MAX_VALUE;
 419         } else {
 420                 if (fthr < MRVDRV_FRAG_MIN_VALUE
 421                     || fthr > MRVDRV_FRAG_MAX_VALUE)
 422                         return -EINVAL;
 423                 adapter->fragthsd = fthr;
 424         }
 425
 426         ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
 427                                     CMD_ACT_SET, CMD_OPTION_WAITFORRSP,
 428                                     OID_802_11_FRAGMENTATION_THRESHOLD, &fthr);
 429
 430         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 431         return ret;
 432 }
 433
 434 static int wlan_get_frag(struct net_device *dev, struct iw_request_info *info,
 435                          struct iw_param *vwrq, char *extra)
 436 {
 437         int ret = 0;
 438         wlan_private *priv = dev->priv;
 439         wlan_adapter *adapter = priv->adapter;
 440
 441         lbs_deb_enter(LBS_DEB_WEXT);
 442
 443         adapter->fragthsd = 0;
 444         ret = libertas_prepare_and_send_command(priv,
 445                                     CMD_802_11_SNMP_MIB,
 446                                     CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
 447                                     OID_802_11_FRAGMENTATION_THRESHOLD, NULL);
 448         if (ret)
 449                 goto out;
 450
 451         vwrq->value = adapter->fragthsd;
 452         vwrq->disabled = ((vwrq->value < MRVDRV_FRAG_MIN_VALUE)
 453                           || (vwrq->value > MRVDRV_FRAG_MAX_VALUE));
 454         vwrq->fixed = 1;
 455
 456 out:
 457         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 458         return ret;
 459 }
 460
 461 static int wlan_get_mode(struct net_device *dev,
 462                          struct iw_request_info *info, u32 * uwrq, char *extra)
 463 {
 464         wlan_private *priv = dev->priv;
 465         wlan_adapter *adapter = priv->adapter;
 466
 467         lbs_deb_enter(LBS_DEB_WEXT);
 468
 469         *uwrq = adapter->mode;
 470
 471         lbs_deb_leave(LBS_DEB_WEXT);
 472         return 0;
 473 }
 474
 475 static int mesh_wlan_get_mode(struct net_device *dev,
 476                               struct iw_request_info *info, u32 * uwrq,
 477                               char *extra)
 478 {
 479         lbs_deb_enter(LBS_DEB_WEXT);
 480
 481         *uwrq = IW_MODE_REPEAT ;
 482
 483         lbs_deb_leave(LBS_DEB_WEXT);
 484         return 0;
 485 }
 486
 487 static int wlan_get_txpow(struct net_device *dev,
 488                           struct iw_request_info *info,
 489                           struct iw_param *vwrq, char *extra)
 490 {
 491         int ret = 0;
 492         wlan_private *priv = dev->priv;
 493         wlan_adapter *adapter = priv->adapter;
 494
 495         lbs_deb_enter(LBS_DEB_WEXT);
 496
 497         ret = libertas_prepare_and_send_command(priv,
 498                                     CMD_802_11_RF_TX_POWER,
 499                                     CMD_ACT_TX_POWER_OPT_GET,
 500                                     CMD_OPTION_WAITFORRSP, 0, NULL);
 501
 502         if (ret)
 503                 goto out;
 504
 505         lbs_deb_wext("tx power level %d dbm\n", adapter->txpowerlevel);
 506         vwrq->value = adapter->txpowerlevel;
 507         vwrq->fixed = 1;
 508         if (adapter->radioon) {
 509                 vwrq->disabled = 0;
 510                 vwrq->flags = IW_TXPOW_DBM;
 511         } else {
 512                 vwrq->disabled = 1;
 513         }
 514
 515 out:
 516         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 517         return ret;
 518 }
 519
 520 static int wlan_set_retry(struct net_device *dev, struct iw_request_info *info,
 521                           struct iw_param *vwrq, char *extra)
 522 {
 523         int ret = 0;
 524         wlan_private *priv = dev->priv;
 525         wlan_adapter *adapter = priv->adapter;
 526
 527         lbs_deb_enter(LBS_DEB_WEXT);
 528
 529         if (vwrq->flags == IW_RETRY_LIMIT) {
 530                 /* The MAC has a 4-bit Total_Tx_Count register
 531                    Total_Tx_Count = 1 + Tx_Retry_Count */
 532 #define TX_RETRY_MIN 0
 533 #define TX_RETRY_MAX 14
 534                 if (vwrq->value < TX_RETRY_MIN || vwrq->value > TX_RETRY_MAX)
 535                         return -EINVAL;
 536
 537                 /* Adding 1 to convert retry count to try count */
 538                 adapter->txretrycount = vwrq->value + 1;
 539
 540                 ret = libertas_prepare_and_send_command(priv, CMD_802_11_SNMP_MIB,
 541                                             CMD_ACT_SET,
 542                                             CMD_OPTION_WAITFORRSP,
 543                                             OID_802_11_TX_RETRYCOUNT, NULL);
 544
 545                 if (ret)
 546                         goto out;
 547         } else {
 548                 return -EOPNOTSUPP;
 549         }
 550
 551 out:
 552         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 553         return ret;
 554 }
 555
 556 static int wlan_get_retry(struct net_device *dev, struct iw_request_info *info,
 557                           struct iw_param *vwrq, char *extra)
 558 {
 559         wlan_private *priv = dev->priv;
 560         wlan_adapter *adapter = priv->adapter;
 561         int ret = 0;
 562
 563         lbs_deb_enter(LBS_DEB_WEXT);
 564
 565         adapter->txretrycount = 0;
 566         ret = libertas_prepare_and_send_command(priv,
 567                                     CMD_802_11_SNMP_MIB,
 568                                     CMD_ACT_GET, CMD_OPTION_WAITFORRSP,
 569                                     OID_802_11_TX_RETRYCOUNT, NULL);
 570         if (ret)
 571                 goto out;
 572
 573         vwrq->disabled = 0;
 574         if (!vwrq->flags) {
 575                 vwrq->flags = IW_RETRY_LIMIT;
 576                 /* Subtract 1 to convert try count to retry count */
 577                 vwrq->value = adapter->txretrycount - 1;
 578         }
 579
 580 out:
 581         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
 582         return ret;
 583 }
 584
 585 static inline void sort_channels(struct iw_freq *freq, int num)
 586 {
 587         int i, j;
 588         struct iw_freq temp;
 589
 590         for (i = 0; i < num; i++)
 591                 for (j = i + 1; j < num; j++)
 592                         if (freq[i].i > freq[j].i) {
 593                                 temp.i = freq[i].i;
 594                                 temp.m = freq[i].m;
 595
 596                                 freq[i].i = freq[j].i;
 597                                 freq[i].m = freq[j].m;
 598
 599                                 freq[j].i = temp.i;
 600                                 freq[j].m = temp.m;
 601                         }
 602 }
 603
 604 /* data rate listing
 605         MULTI_BANDS:
 606                 abg             a       b       b/g
 607    Infra        G(12)           A(8)    B(4)    G(12)
 608    Adhoc        A+B(12)         A(8)    B(4)    B(4)
 609
 610         non-MULTI_BANDS:
 611                                         b       b/g
 612    Infra                                B(4)    G(12)
 613    Adhoc                                B(4)    B(4)
 614  */
 615 /**
 616  *  @brief Get Range Info
 617  *
 618  *  @param dev                  A pointer to net_device structure
 619  *  @param info                 A pointer to iw_request_info structure
 620  *  @param vwrq                 A pointer to iw_param structure
 621  *  @param extra                A pointer to extra data buf
 622  *  @return                     0 --success, otherwise fail
 623  */
 624 static int wlan_get_range(struct net_device *dev, struct iw_request_info *info,
 625                           struct iw_point *dwrq, char *extra)
 626 {
 627         int i, j;
 628         wlan_private *priv = dev->priv;
 629         wlan_adapter *adapter = priv->adapter;
 630         struct iw_range *range = (struct iw_range *)extra;
 631         struct chan_freq_power *cfp;
 632         u8 rates[MAX_RATES + 1];
 633
 634         u8 flag = 0;
 635
 636         lbs_deb_enter(LBS_DEB_WEXT);
 637
 638         dwrq->length = sizeof(struct iw_range);
 639         memset(range, 0, sizeof(struct iw_range));
 640
 641         range->min_nwid = 0;
 642         range->max_nwid = 0;
 643
 644         memset(rates, 0, sizeof(rates));
 645         copy_active_data_rates(adapter, rates);
 646         range->num_bitrates = strnlen(rates, IW_MAX_BITRATES);
 647         for (i = 0; i < range->num_bitrates; i++)
 648                 range->bitrate[i] = rates[i] * 500000;
 649         range->num_bitrates = i;
 650         lbs_deb_wext("IW_MAX_BITRATES %d, num_bitrates %d\n", IW_MAX_BITRATES,
 651                range->num_bitrates);
 652
 653         range->num_frequency = 0;
 654         if (priv->adapter->enable11d &&
 655             adapter->connect_status == LIBERTAS_CONNECTED) {
 656                 u8 chan_no;
 657                 u8 band;
 658
 659                 struct parsed_region_chan_11d *parsed_region_chan =
 660                     &adapter->parsed_region_chan;
 661
 662                 if (parsed_region_chan == NULL) {
 663                         lbs_deb_wext("11d: parsed_region_chan is NULL\n");
 664                         goto out;
 665                 }
 666                 band = parsed_region_chan->band;
 667                 lbs_deb_wext("band %d, nr_char %d\n", band,
 668                        parsed_region_chan->nr_chan);
 669
 670                 for (i = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
 671                      && (i < parsed_region_chan->nr_chan); i++) {
 672                         chan_no = parsed_region_chan->chanpwr[i].chan;
 673                         lbs_deb_wext("chan_no %d\n", chan_no);
 674                         range->freq[range->num_frequency].i = (long)chan_no;
 675                         range->freq[range->num_frequency].m =
 676                             (long)libertas_chan_2_freq(chan_no, band) * 100000;
 677                         range->freq[range->num_frequency].e = 1;
 678                         range->num_frequency++;
 679                 }
 680                 flag = 1;
 681         }
 682         if (!flag) {
 683                 for (j = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
 684                      && (j < sizeof(adapter->region_channel)
 685                          / sizeof(adapter->region_channel[0])); j++) {
 686                         cfp = adapter->region_channel[j].CFP;
 687                         for (i = 0; (range->num_frequency < IW_MAX_FREQUENCIES)
 688                              && adapter->region_channel[j].valid
 689                              && cfp
 690                              && (i < adapter->region_channel[j].nrcfp); i++) {
 691                                 range->freq[range->num_frequency].i =
 692                                     (long)cfp->channel;
 693                                 range->freq[range->num_frequency].m =
 694                                     (long)cfp->freq * 100000;
 695                                 range->freq[range->num_frequency].e = 1;
 696                                 cfp++;
 697                                 range->num_frequency++;
 698                         }
 699                 }
 700         }
 701
 702         lbs_deb_wext("IW_MAX_FREQUENCIES %d, num_frequency %d\n",
 703                IW_MAX_FREQUENCIES, range->num_frequency);
 704
 705         range->num_channels = range->num_frequency;
 706
 707         sort_channels(&range->freq[0], range->num_frequency);
 708
 709         /*
 710          * Set an indication of the max TCP throughput in bit/s that we can
 711          * expect using this interface
 712          */
 713         if (i > 2)
 714                 range->throughput = 5000 * 1000;
 715         else
 716                 range->throughput = 1500 * 1000;
 717
 718         range->min_rts = MRVDRV_RTS_MIN_VALUE;
 719         range->max_rts = MRVDRV_RTS_MAX_VALUE;
 720         range->min_frag = MRVDRV_FRAG_MIN_VALUE;
 721         range->max_frag = MRVDRV_FRAG_MAX_VALUE;
 722
 723         range->encoding_size[0] = 5;
 724         range->encoding_size[1] = 13;
 725         range->num_encoding_sizes = 2;
 726         range->max_encoding_tokens = 4;
 727
 728         range->min_pmp = 1000000;
 729         range->max_pmp = 120000000;
 730         range->min_pmt = 1000;
 731         range->max_pmt = 1000000;
 732         range->pmp_flags = IW_POWER_PERIOD;
 733         range->pmt_flags = IW_POWER_TIMEOUT;
 734         range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
 735
 736         /*
 737          * Minimum version we recommend
 738          */
 739         range->we_version_source = 15;
 740
 741         /*
 742          * Version we are compiled with
 743          */
 744         range->we_version_compiled = WIRELESS_EXT;
 745
 746         range->retry_capa = IW_RETRY_LIMIT;
 747         range->retry_flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
 748
 749         range->min_retry = TX_RETRY_MIN;
 750         range->max_retry = TX_RETRY_MAX;
 751
 752         /*
 753          * Set the qual, level and noise range values
 754          */
 755         range->max_qual.qual = 100;
 756         range->max_qual.level = 0;
 757         range->max_qual.noise = 0;
 758         range->max_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 759
 760         range->avg_qual.qual = 70;
 761         /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
 762         range->avg_qual.level = 0;
 763         range->avg_qual.noise = 0;
 764         range->avg_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 765
 766         range->sensitivity = 0;
 767
 768         /*
 769          * Setup the supported power level ranges
 770          */
 771         memset(range->txpower, 0, sizeof(range->txpower));
 772         range->txpower[0] = 5;
 773         range->txpower[1] = 7;
 774         range->txpower[2] = 9;
 775         range->txpower[3] = 11;
 776         range->txpower[4] = 13;
 777         range->txpower[5] = 15;
 778         range->txpower[6] = 17;
 779         range->txpower[7] = 19;
 780
 781         range->num_txpower = 8;
 782         range->txpower_capa = IW_TXPOW_DBM;
 783         range->txpower_capa |= IW_TXPOW_RANGE;
 784
 785         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
 786                                 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
 787                                 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
 788         range->event_capa[1] = IW_EVENT_CAPA_K_1;
 789
 790         if (adapter->fwcapinfo & FW_CAPINFO_WPA) {
 791                 range->enc_capa =   IW_ENC_CAPA_WPA
 792                                   | IW_ENC_CAPA_WPA2
 793                                   | IW_ENC_CAPA_CIPHER_TKIP
 794                                   | IW_ENC_CAPA_CIPHER_CCMP;
 795         }
 796
 797 out:
 798         lbs_deb_leave(LBS_DEB_WEXT);
 799         return 0;
 800 }
 801
 802 static int wlan_set_power(struct net_device *dev, struct iw_request_info *info,
 803                           struct iw_param *vwrq, char *extra)
 804 {
 805         wlan_private *priv = dev->priv;
 806         wlan_adapter *adapter = priv->adapter;
 807
 808         lbs_deb_enter(LBS_DEB_WEXT);
 809
 810         /* PS is currently supported only in Infrastructure mode
 811          * Remove this check if it is to be supported in IBSS mode also
 812          */
 813
 814         if (vwrq->disabled) {
 815                 adapter->psmode = WLAN802_11POWERMODECAM;
 816                 if (adapter->psstate != PS_STATE_FULL_POWER) {
 817                         libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
 818                 }
 819
 820                 return 0;
 821         }
 822
 823         if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
 824                 lbs_deb_wext(
 825                        "setting power timeout is not supported\n");
 826                 return -EINVAL;
 827         } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
 828                 lbs_deb_wext("setting power period not supported\n");
 829                 return -EINVAL;
 830         }
 831
 832         if (adapter->psmode != WLAN802_11POWERMODECAM) {
 833                 return 0;
 834         }
 835
 836         adapter->psmode = WLAN802_11POWERMODEMAX_PSP;
 837
 838         if (adapter->connect_status == LIBERTAS_CONNECTED) {
 839                 libertas_ps_sleep(priv, CMD_OPTION_WAITFORRSP);
 840         }
 841
 842         lbs_deb_leave(LBS_DEB_WEXT);
 843         return 0;
 844 }
 845
 846 static int wlan_get_power(struct net_device *dev, struct iw_request_info *info,
 847                           struct iw_param *vwrq, char *extra)
 848 {
 849         wlan_private *priv = dev->priv;
 850         wlan_adapter *adapter = priv->adapter;
 851         int mode;
 852
 853         lbs_deb_enter(LBS_DEB_WEXT);
 854
 855         mode = adapter->psmode;
 856
 857         if ((vwrq->disabled = (mode == WLAN802_11POWERMODECAM))
 858             || adapter->connect_status == LIBERTAS_DISCONNECTED)
 859         {
 860                 goto out;
 861         }
 862
 863         vwrq->value = 0;
 864
 865 out:
 866         lbs_deb_leave(LBS_DEB_WEXT);
 867         return 0;
 868 }
 869
 870 static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
 871 {
 872         enum {
 873                 POOR = 30,
 874                 FAIR = 60,
 875                 GOOD = 80,
 876                 VERY_GOOD = 90,
 877                 EXCELLENT = 95,
 878                 PERFECT = 100
 879         };
 880         wlan_private *priv = dev->priv;
 881         wlan_adapter *adapter = priv->adapter;
 882         u32 rssi_qual;
 883         u32 tx_qual;
 884         u32 quality = 0;
 885         int stats_valid = 0;
 886         u8 rssi;
 887         u32 tx_retries;
 888
 889         lbs_deb_enter(LBS_DEB_WEXT);
 890
 891         priv->wstats.status = adapter->mode;
 892
 893         /* If we're not associated, all quality values are meaningless */
 894         if (adapter->connect_status != LIBERTAS_CONNECTED)
 895                 goto out;
 896
 897         /* Quality by RSSI */
 898         priv->wstats.qual.level =
 899             CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
 900              adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
 901
 902         if (adapter->NF[TYPE_BEACON][TYPE_NOAVG] == 0) {
 903                 priv->wstats.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE;
 904         } else {
 905                 priv->wstats.qual.noise =
 906                     CAL_NF(adapter->NF[TYPE_BEACON][TYPE_NOAVG]);
 907         }
 908
 909         lbs_deb_wext("signal level %#x\n", priv->wstats.qual.level);
 910         lbs_deb_wext("noise %#x\n", priv->wstats.qual.noise);
 911
 912         rssi = priv->wstats.qual.level - priv->wstats.qual.noise;
 913         if (rssi < 15)
 914                 rssi_qual = rssi * POOR / 10;
 915         else if (rssi < 20)
 916                 rssi_qual = (rssi - 15) * (FAIR - POOR) / 5 + POOR;
 917         else if (rssi < 30)
 918                 rssi_qual = (rssi - 20) * (GOOD - FAIR) / 5 + FAIR;
 919         else if (rssi < 40)
 920                 rssi_qual = (rssi - 30) * (VERY_GOOD - GOOD) /
 921                     10 + GOOD;
 922         else
 923                 rssi_qual = (rssi - 40) * (PERFECT - VERY_GOOD) /
 924                     10 + VERY_GOOD;
 925         quality = rssi_qual;
 926
 927         /* Quality by TX errors */
 928         priv->wstats.discard.retries = priv->stats.tx_errors;
 929
 930         tx_retries = le16_to_cpu(adapter->logmsg.retry);
 931
 932         if (tx_retries > 75)
 933                 tx_qual = (90 - tx_retries) * POOR / 15;
 934         else if (tx_retries > 70)
 935                 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
 936         else if (tx_retries > 65)
 937                 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
 938         else if (tx_retries > 50)
 939                 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
 940                     15 + GOOD;
 941         else
 942                 tx_qual = (50 - tx_retries) *
 943                     (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
 944         quality = min(quality, tx_qual);
 945
 946         priv->wstats.discard.code = le16_to_cpu(adapter->logmsg.wepundecryptable);
 947         priv->wstats.discard.fragment = le16_to_cpu(adapter->logmsg.rxfrag);
 948         priv->wstats.discard.retries = tx_retries;
 949         priv->wstats.discard.misc = le16_to_cpu(adapter->logmsg.ackfailure);
 950
 951         /* Calculate quality */
 952         priv->wstats.qual.qual = max(quality, (u32)100);
 953         priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 954         stats_valid = 1;
 955
 956         /* update stats asynchronously for future calls */
 957         libertas_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
 958                                         0, 0, NULL);
 959         libertas_prepare_and_send_command(priv, CMD_802_11_GET_LOG, 0,
 960                                         0, 0, NULL);
 961 out:
 962         if (!stats_valid) {
 963                 priv->wstats.miss.beacon = 0;
 964                 priv->wstats.discard.retries = 0;
 965                 priv->wstats.qual.qual = 0;
 966                 priv->wstats.qual.level = 0;
 967                 priv->wstats.qual.noise = 0;
 968                 priv->wstats.qual.updated = IW_QUAL_ALL_UPDATED;
 969                 priv->wstats.qual.updated |= IW_QUAL_NOISE_INVALID |
 970                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
 971         }
 972
 973         lbs_deb_leave(LBS_DEB_WEXT);
 974         return &priv->wstats;
 975
 976
 977 }
 978
 979 static int wlan_set_freq(struct net_device *dev, struct iw_request_info *info,
 980                   struct iw_freq *fwrq, char *extra)
 981 {
 982         int ret = -EINVAL;
 983         wlan_private *priv = dev->priv;
 984         wlan_adapter *adapter = priv->adapter;
 985         struct chan_freq_power *cfp;
 986         struct assoc_request * assoc_req;
 987
 988         lbs_deb_enter(LBS_DEB_WEXT);
 989
 990         mutex_lock(&adapter->lock);
 991         assoc_req = wlan_get_association_request(adapter);
 992         if (!assoc_req) {
 993                 ret = -ENOMEM;
 994                 goto out;
 995         }
 996
 997         /* If setting by frequency, convert to a channel */
 998         if (fwrq->e == 1) {
 999                 long f = fwrq->m / 100000;
1000
1001                 cfp = find_cfp_by_band_and_freq(adapter, 0, f);
1002                 if (!cfp) {
1003                         lbs_deb_wext("invalid freq %ld\n", f);
1004                         goto out;
1005                 }
1006
1007                 fwrq->e = 0;
1008                 fwrq->m = (int) cfp->channel;
1009         }
1010
1011         /* Setting by channel number */
1012         if (fwrq->m > 1000 || fwrq->e > 0) {
1013                 goto out;
1014         }
1015
1016         cfp = libertas_find_cfp_by_band_and_channel(adapter, 0, fwrq->m);
1017         if (!cfp) {
1018                 goto out;
1019         }
1020
1021         assoc_req->channel = fwrq->m;
1022         ret = 0;
1023
1024 out:
1025         if (ret == 0) {
1026                 set_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags);
1027                 wlan_postpone_association_work(priv);
1028         } else {
1029                 wlan_cancel_association_work(priv);
1030         }
1031         mutex_unlock(&adapter->lock);
1032
1033         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1034         return ret;
1035 }
1036
1037 static int wlan_set_rate(struct net_device *dev, struct iw_request_info *info,
1038                   struct iw_param *vwrq, char *extra)
1039 {
1040         wlan_private *priv = dev->priv;
1041         wlan_adapter *adapter = priv->adapter;
1042         u32 new_rate;
1043         u16 action;
1044         int ret = -EINVAL;
1045         u8 rates[MAX_RATES + 1];
1046
1047         lbs_deb_enter(LBS_DEB_WEXT);
1048         lbs_deb_wext("vwrq->value %d\n", vwrq->value);
1049
1050         /* Auto rate? */
1051         if (vwrq->value == -1) {
1052                 action = CMD_ACT_SET_TX_AUTO;
1053                 adapter->auto_rate = 1;
1054                 adapter->cur_rate = 0;
1055         } else {
1056                 if (vwrq->value % 100000)
1057                         goto out;
1058
1059                 memset(rates, 0, sizeof(rates));
1060                 copy_active_data_rates(adapter, rates);
1061                 new_rate = vwrq->value / 500000;
1062                 if (!memchr(rates, new_rate, sizeof(rates))) {
1063                         lbs_pr_alert("fixed data rate 0x%X out of range\n",
1064                                 new_rate);
1065                         goto out;
1066                 }
1067
1068                 adapter->cur_rate = new_rate;
1069                 action = CMD_ACT_SET_TX_FIX_RATE;
1070                 adapter->auto_rate = 0;
1071         }
1072
1073         ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
1074                                     action, CMD_OPTION_WAITFORRSP, 0, NULL);
1075
1076 out:
1077         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1078         return ret;
1079 }
1080
1081 static int wlan_get_rate(struct net_device *dev, struct iw_request_info *info,
1082                   struct iw_param *vwrq, char *extra)
1083 {
1084         wlan_private *priv = dev->priv;
1085         wlan_adapter *adapter = priv->adapter;
1086
1087         lbs_deb_enter(LBS_DEB_WEXT);
1088
1089         if (adapter->connect_status == LIBERTAS_CONNECTED) {
1090                 vwrq->value = adapter->cur_rate * 500000;
1091
1092                 if (adapter->auto_rate)
1093                         vwrq->fixed = 0;
1094                 else
1095                         vwrq->fixed = 1;
1096
1097         } else {
1098                 vwrq->fixed = 0;
1099                 vwrq->value = 0;
1100         }
1101
1102         lbs_deb_leave(LBS_DEB_WEXT);
1103         return 0;
1104 }
1105
1106 static int wlan_set_mode(struct net_device *dev,
1107                   struct iw_request_info *info, u32 * uwrq, char *extra)
1108 {
1109         int ret = 0;
1110         wlan_private *priv = dev->priv;
1111         wlan_adapter *adapter = priv->adapter;
1112         struct assoc_request * assoc_req;
1113
1114         lbs_deb_enter(LBS_DEB_WEXT);
1115
1116         if (   (*uwrq != IW_MODE_ADHOC)
1117             && (*uwrq != IW_MODE_INFRA)
1118             && (*uwrq != IW_MODE_AUTO)) {
1119                 lbs_deb_wext("Invalid mode: 0x%x\n", *uwrq);
1120                 ret = -EINVAL;
1121                 goto out;
1122         }
1123
1124         mutex_lock(&adapter->lock);
1125         assoc_req = wlan_get_association_request(adapter);
1126         if (!assoc_req) {
1127                 ret = -ENOMEM;
1128                 wlan_cancel_association_work(priv);
1129         } else {
1130                 assoc_req->mode = *uwrq;
1131                 set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
1132                 wlan_postpone_association_work(priv);
1133                 lbs_deb_wext("Switching to mode: 0x%x\n", *uwrq);
1134         }
1135         mutex_unlock(&adapter->lock);
1136
1137 out:
1138         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1139         return ret;
1140 }
1141
1142
1143 /**
1144  *  @brief Get Encryption key
1145  *
1146  *  @param dev                  A pointer to net_device structure
1147  *  @param info                 A pointer to iw_request_info structure
1148  *  @param vwrq                 A pointer to iw_param structure
1149  *  @param extra                A pointer to extra data buf
1150  *  @return                     0 --success, otherwise fail
1151  */
1152 static int wlan_get_encode(struct net_device *dev,
1153                            struct iw_request_info *info,
1154                            struct iw_point *dwrq, u8 * extra)
1155 {
1156         wlan_private *priv = dev->priv;
1157         wlan_adapter *adapter = priv->adapter;
1158         int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1159
1160         lbs_deb_enter(LBS_DEB_WEXT);
1161
1162         lbs_deb_wext("flags 0x%x, index %d, length %d, wep_tx_keyidx %d\n",
1163                dwrq->flags, index, dwrq->length, adapter->wep_tx_keyidx);
1164
1165         dwrq->flags = 0;
1166
1167         /* Authentication method */
1168         switch (adapter->secinfo.auth_mode) {
1169         case IW_AUTH_ALG_OPEN_SYSTEM:
1170                 dwrq->flags = IW_ENCODE_OPEN;
1171                 break;
1172
1173         case IW_AUTH_ALG_SHARED_KEY:
1174         case IW_AUTH_ALG_LEAP:
1175                 dwrq->flags = IW_ENCODE_RESTRICTED;
1176                 break;
1177         default:
1178                 dwrq->flags = IW_ENCODE_DISABLED | IW_ENCODE_OPEN;
1179                 break;
1180         }
1181
1182         if (   adapter->secinfo.wep_enabled
1183             || adapter->secinfo.WPAenabled
1184             || adapter->secinfo.WPA2enabled) {
1185                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1186         } else {
1187                 dwrq->flags |= IW_ENCODE_DISABLED;
1188         }
1189
1190         memset(extra, 0, 16);
1191
1192         mutex_lock(&adapter->lock);
1193
1194         /* Default to returning current transmit key */
1195         if (index < 0)
1196                 index = adapter->wep_tx_keyidx;
1197
1198         if ((adapter->wep_keys[index].len) && adapter->secinfo.wep_enabled) {
1199                 memcpy(extra, adapter->wep_keys[index].key,
1200                        adapter->wep_keys[index].len);
1201                 dwrq->length = adapter->wep_keys[index].len;
1202
1203                 dwrq->flags |= (index + 1);
1204                 /* Return WEP enabled */
1205                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1206         } else if ((adapter->secinfo.WPAenabled)
1207                    || (adapter->secinfo.WPA2enabled)) {
1208                 /* return WPA enabled */
1209                 dwrq->flags &= ~IW_ENCODE_DISABLED;
1210         } else {
1211                 dwrq->flags |= IW_ENCODE_DISABLED;
1212         }
1213
1214         mutex_unlock(&adapter->lock);
1215
1216         dwrq->flags |= IW_ENCODE_NOKEY;
1217
1218         lbs_deb_wext("key: " MAC_FMT ", keylen %d\n",
1219                extra[0], extra[1], extra[2],
1220                extra[3], extra[4], extra[5], dwrq->length);
1221
1222         lbs_deb_wext("return flags 0x%x\n", dwrq->flags);
1223
1224         lbs_deb_leave(LBS_DEB_WEXT);
1225         return 0;
1226 }
1227
1228 /**
1229  *  @brief Set Encryption key (internal)
1230  *
1231  *  @param priv                 A pointer to private card structure
1232  *  @param key_material         A pointer to key material
1233  *  @param key_length           length of key material
1234  *  @param index                key index to set
1235  *  @param set_tx_key           Force set TX key (1 = yes, 0 = no)
1236  *  @return                     0 --success, otherwise fail
1237  */
1238 static int wlan_set_wep_key(struct assoc_request *assoc_req,
1239                             const char *key_material,
1240                             u16 key_length,
1241                             u16 index,
1242                             int set_tx_key)
1243 {
1244         int ret = 0;
1245         struct enc_key *pkey;
1246
1247         lbs_deb_enter(LBS_DEB_WEXT);
1248
1249         /* Paranoid validation of key index */
1250         if (index > 3) {
1251                 ret = -EINVAL;
1252                 goto out;
1253         }
1254
1255         /* validate max key length */
1256         if (key_length > KEY_LEN_WEP_104) {
1257                 ret = -EINVAL;
1258                 goto out;
1259         }
1260
1261         pkey = &assoc_req->wep_keys[index];
1262
1263         if (key_length > 0) {
1264                 memset(pkey, 0, sizeof(struct enc_key));
1265                 pkey->type = KEY_TYPE_ID_WEP;
1266
1267                 /* Standardize the key length */
1268                 pkey->len = (key_length > KEY_LEN_WEP_40) ?
1269                                 KEY_LEN_WEP_104 : KEY_LEN_WEP_40;
1270                 memcpy(pkey->key, key_material, key_length);
1271         }
1272
1273         if (set_tx_key) {
1274                 /* Ensure the chosen key is valid */
1275                 if (!pkey->len) {
1276                         lbs_deb_wext("key not set, so cannot enable it\n");
1277                         ret = -EINVAL;
1278                         goto out;
1279                 }
1280                 assoc_req->wep_tx_keyidx = index;
1281         }
1282
1283         assoc_req->secinfo.wep_enabled = 1;
1284
1285 out:
1286         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1287         return ret;
1288 }
1289
1290 static int validate_key_index(u16 def_index, u16 raw_index,
1291                               u16 *out_index, u16 *is_default)
1292 {
1293         if (!out_index || !is_default)
1294                 return -EINVAL;
1295
1296         /* Verify index if present, otherwise use default TX key index */
1297         if (raw_index > 0) {
1298                 if (raw_index > 4)
1299                         return -EINVAL;
1300                 *out_index = raw_index - 1;
1301         } else {
1302                 *out_index = def_index;
1303                 *is_default = 1;
1304         }
1305         return 0;
1306 }
1307
1308 static void disable_wep(struct assoc_request *assoc_req)
1309 {
1310         int i;
1311
1312         lbs_deb_enter(LBS_DEB_WEXT);
1313
1314         /* Set Open System auth mode */
1315         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1316
1317         /* Clear WEP keys and mark WEP as disabled */
1318         assoc_req->secinfo.wep_enabled = 0;
1319         for (i = 0; i < 4; i++)
1320                 assoc_req->wep_keys[i].len = 0;
1321
1322         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1323         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1324
1325         lbs_deb_leave(LBS_DEB_WEXT);
1326 }
1327
1328 static void disable_wpa(struct assoc_request *assoc_req)
1329 {
1330         lbs_deb_enter(LBS_DEB_WEXT);
1331
1332         memset(&assoc_req->wpa_mcast_key, 0, sizeof (struct enc_key));
1333         assoc_req->wpa_mcast_key.flags = KEY_INFO_WPA_MCAST;
1334         set_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
1335
1336         memset(&assoc_req->wpa_unicast_key, 0, sizeof (struct enc_key));
1337         assoc_req->wpa_unicast_key.flags = KEY_INFO_WPA_UNICAST;
1338         set_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
1339
1340         assoc_req->secinfo.WPAenabled = 0;
1341         assoc_req->secinfo.WPA2enabled = 0;
1342         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1343
1344         lbs_deb_leave(LBS_DEB_WEXT);
1345 }
1346
1347 /**
1348  *  @brief Set Encryption key
1349  *
1350  *  @param dev                  A pointer to net_device structure
1351  *  @param info                 A pointer to iw_request_info structure
1352  *  @param vwrq                 A pointer to iw_param structure
1353  *  @param extra                A pointer to extra data buf
1354  *  @return                     0 --success, otherwise fail
1355  */
1356 static int wlan_set_encode(struct net_device *dev,
1357                     struct iw_request_info *info,
1358                     struct iw_point *dwrq, char *extra)
1359 {
1360         int ret = 0;
1361         wlan_private *priv = dev->priv;
1362         wlan_adapter *adapter = priv->adapter;
1363         struct assoc_request * assoc_req;
1364         u16 is_default = 0, index = 0, set_tx_key = 0;
1365
1366         lbs_deb_enter(LBS_DEB_WEXT);
1367
1368         mutex_lock(&adapter->lock);
1369         assoc_req = wlan_get_association_request(adapter);
1370         if (!assoc_req) {
1371                 ret = -ENOMEM;
1372                 goto out;
1373         }
1374
1375         if (dwrq->flags & IW_ENCODE_DISABLED) {
1376                 disable_wep (assoc_req);
1377                 disable_wpa (assoc_req);
1378                 goto out;
1379         }
1380
1381         ret = validate_key_index(assoc_req->wep_tx_keyidx,
1382                                  (dwrq->flags & IW_ENCODE_INDEX),
1383                                  &index, &is_default);
1384         if (ret) {
1385                 ret = -EINVAL;
1386                 goto out;
1387         }
1388
1389         /* If WEP isn't enabled, or if there is no key data but a valid
1390          * index, set the TX key.
1391          */
1392         if (!assoc_req->secinfo.wep_enabled || (dwrq->length == 0 && !is_default))
1393                 set_tx_key = 1;
1394
1395         ret = wlan_set_wep_key(assoc_req, extra, dwrq->length, index, set_tx_key);
1396         if (ret)
1397                 goto out;
1398
1399         if (dwrq->length)
1400                 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1401         if (set_tx_key)
1402                 set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
1403
1404         if (dwrq->flags & IW_ENCODE_RESTRICTED) {
1405                 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
1406         } else if (dwrq->flags & IW_ENCODE_OPEN) {
1407                 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1408         }
1409
1410 out:
1411         if (ret == 0) {
1412                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1413                 wlan_postpone_association_work(priv);
1414         } else {
1415                 wlan_cancel_association_work(priv);
1416         }
1417         mutex_unlock(&adapter->lock);
1418
1419         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1420         return ret;
1421 }
1422
1423 /**
1424  *  @brief Get Extended Encryption key (WPA/802.1x and WEP)
1425  *
1426  *  @param dev                  A pointer to net_device structure
1427  *  @param info                 A pointer to iw_request_info structure
1428  *  @param vwrq                 A pointer to iw_param structure
1429  *  @param extra                A pointer to extra data buf
1430  *  @return                     0 on success, otherwise failure
1431  */
1432 static int wlan_get_encodeext(struct net_device *dev,
1433                               struct iw_request_info *info,
1434                               struct iw_point *dwrq,
1435                               char *extra)
1436 {
1437         int ret = -EINVAL;
1438         wlan_private *priv = dev->priv;
1439         wlan_adapter *adapter = priv->adapter;
1440         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1441         int index, max_key_len;
1442
1443         lbs_deb_enter(LBS_DEB_WEXT);
1444
1445         max_key_len = dwrq->length - sizeof(*ext);
1446         if (max_key_len < 0)
1447                 goto out;
1448
1449         index = dwrq->flags & IW_ENCODE_INDEX;
1450         if (index) {
1451                 if (index < 1 || index > 4)
1452                         goto out;
1453                 index--;
1454         } else {
1455                 index = adapter->wep_tx_keyidx;
1456         }
1457
1458         if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
1459             ext->alg != IW_ENCODE_ALG_WEP) {
1460                 if (index != 0 || adapter->mode != IW_MODE_INFRA)
1461                         goto out;
1462         }
1463
1464         dwrq->flags = index + 1;
1465         memset(ext, 0, sizeof(*ext));
1466
1467         if (   !adapter->secinfo.wep_enabled
1468             && !adapter->secinfo.WPAenabled
1469             && !adapter->secinfo.WPA2enabled) {
1470                 ext->alg = IW_ENCODE_ALG_NONE;
1471                 ext->key_len = 0;
1472                 dwrq->flags |= IW_ENCODE_DISABLED;
1473         } else {
1474                 u8 *key = NULL;
1475
1476                 if (   adapter->secinfo.wep_enabled
1477                     && !adapter->secinfo.WPAenabled
1478                     && !adapter->secinfo.WPA2enabled) {
1479                         /* WEP */
1480                         ext->alg = IW_ENCODE_ALG_WEP;
1481                         ext->key_len = adapter->wep_keys[index].len;
1482                         key = &adapter->wep_keys[index].key[0];
1483                 } else if (   !adapter->secinfo.wep_enabled
1484                            && (adapter->secinfo.WPAenabled ||
1485                                adapter->secinfo.WPA2enabled)) {
1486                         /* WPA */
1487                         struct enc_key * pkey = NULL;
1488
1489                         if (   adapter->wpa_mcast_key.len
1490                             && (adapter->wpa_mcast_key.flags & KEY_INFO_WPA_ENABLED))
1491                                 pkey = &adapter->wpa_mcast_key;
1492                         else if (   adapter->wpa_unicast_key.len
1493                                  && (adapter->wpa_unicast_key.flags & KEY_INFO_WPA_ENABLED))
1494                                 pkey = &adapter->wpa_unicast_key;
1495
1496                         if (pkey) {
1497                                 if (pkey->type == KEY_TYPE_ID_AES) {
1498                                         ext->alg = IW_ENCODE_ALG_CCMP;
1499                                 } else {
1500                                         ext->alg = IW_ENCODE_ALG_TKIP;
1501                                 }
1502                                 ext->key_len = pkey->len;
1503                                 key = &pkey->key[0];
1504                         } else {
1505                                 ext->alg = IW_ENCODE_ALG_TKIP;
1506                                 ext->key_len = 0;
1507                         }
1508                 } else {
1509                         goto out;
1510                 }
1511
1512                 if (ext->key_len > max_key_len) {
1513                         ret = -E2BIG;
1514                         goto out;
1515                 }
1516
1517                 if (ext->key_len)
1518                         memcpy(ext->key, key, ext->key_len);
1519                 else
1520                         dwrq->flags |= IW_ENCODE_NOKEY;
1521                 dwrq->flags |= IW_ENCODE_ENABLED;
1522         }
1523         ret = 0;
1524
1525 out:
1526         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1527         return ret;
1528 }
1529
1530 /**
1531  *  @brief Set Encryption key Extended (WPA/802.1x and WEP)
1532  *
1533  *  @param dev                  A pointer to net_device structure
1534  *  @param info                 A pointer to iw_request_info structure
1535  *  @param vwrq                 A pointer to iw_param structure
1536  *  @param extra                A pointer to extra data buf
1537  *  @return                     0 --success, otherwise fail
1538  */
1539 static int wlan_set_encodeext(struct net_device *dev,
1540                               struct iw_request_info *info,
1541                               struct iw_point *dwrq,
1542                               char *extra)
1543 {
1544         int ret = 0;
1545         wlan_private *priv = dev->priv;
1546         wlan_adapter *adapter = priv->adapter;
1547         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1548         int alg = ext->alg;
1549         struct assoc_request * assoc_req;
1550
1551         lbs_deb_enter(LBS_DEB_WEXT);
1552
1553         mutex_lock(&adapter->lock);
1554         assoc_req = wlan_get_association_request(adapter);
1555         if (!assoc_req) {
1556                 ret = -ENOMEM;
1557                 goto out;
1558         }
1559
1560         if ((alg == IW_ENCODE_ALG_NONE) || (dwrq->flags & IW_ENCODE_DISABLED)) {
1561                 disable_wep (assoc_req);
1562                 disable_wpa (assoc_req);
1563         } else if (alg == IW_ENCODE_ALG_WEP) {
1564                 u16 is_default = 0, index, set_tx_key = 0;
1565
1566                 ret = validate_key_index(assoc_req->wep_tx_keyidx,
1567                                          (dwrq->flags & IW_ENCODE_INDEX),
1568                                          &index, &is_default);
1569                 if (ret)
1570                         goto out;
1571
1572                 /* If WEP isn't enabled, or if there is no key data but a valid
1573                  * index, or if the set-TX-key flag was passed, set the TX key.
1574                  */
1575                 if (   !assoc_req->secinfo.wep_enabled
1576                     || (dwrq->length == 0 && !is_default)
1577                     || (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY))
1578                         set_tx_key = 1;
1579
1580                 /* Copy key to driver */
1581                 ret = wlan_set_wep_key (assoc_req, ext->key, ext->key_len, index,
1582                                         set_tx_key);
1583                 if (ret)
1584                         goto out;
1585
1586                 if (dwrq->flags & IW_ENCODE_RESTRICTED) {
1587                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
1588                 } else if (dwrq->flags & IW_ENCODE_OPEN) {
1589                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1590                 }
1591
1592                 /* Mark the various WEP bits as modified */
1593                 set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1594                 if (dwrq->length)
1595                         set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
1596                 if (set_tx_key)
1597                         set_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags);
1598         } else if ((alg == IW_ENCODE_ALG_TKIP) || (alg == IW_ENCODE_ALG_CCMP)) {
1599                 struct enc_key * pkey;
1600
1601                 /* validate key length */
1602                 if (((alg == IW_ENCODE_ALG_TKIP)
1603                         && (ext->key_len != KEY_LEN_WPA_TKIP))
1604                     || ((alg == IW_ENCODE_ALG_CCMP)
1605                         && (ext->key_len != KEY_LEN_WPA_AES))) {
1606                                 lbs_deb_wext("invalid size %d for key of alg"
1607                                        "type %d\n",
1608                                        ext->key_len,
1609                                        alg);
1610                                 ret = -EINVAL;
1611                                 goto out;
1612                 }
1613
1614                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
1615                         pkey = &assoc_req->wpa_mcast_key;
1616                         set_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
1617                 } else {
1618                         pkey = &assoc_req->wpa_unicast_key;
1619                         set_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
1620                 }
1621
1622                 memset(pkey, 0, sizeof (struct enc_key));
1623                 memcpy(pkey->key, ext->key, ext->key_len);
1624                 pkey->len = ext->key_len;
1625                 if (pkey->len)
1626                         pkey->flags |= KEY_INFO_WPA_ENABLED;
1627
1628                 /* Do this after zeroing key structure */
1629                 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
1630                         pkey->flags |= KEY_INFO_WPA_MCAST;
1631                 } else {
1632                         pkey->flags |= KEY_INFO_WPA_UNICAST;
1633                 }
1634
1635                 if (alg == IW_ENCODE_ALG_TKIP) {
1636                         pkey->type = KEY_TYPE_ID_TKIP;
1637                 } else if (alg == IW_ENCODE_ALG_CCMP) {
1638                         pkey->type = KEY_TYPE_ID_AES;
1639                 }
1640
1641                 /* If WPA isn't enabled yet, do that now */
1642                 if (   assoc_req->secinfo.WPAenabled == 0
1643                     && assoc_req->secinfo.WPA2enabled == 0) {
1644                         assoc_req->secinfo.WPAenabled = 1;
1645                         assoc_req->secinfo.WPA2enabled = 1;
1646                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1647                 }
1648
1649                 disable_wep (assoc_req);
1650         }
1651
1652 out:
1653         if (ret == 0) {
1654                 wlan_postpone_association_work(priv);
1655         } else {
1656                 wlan_cancel_association_work(priv);
1657         }
1658         mutex_unlock(&adapter->lock);
1659
1660         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1661         return ret;
1662 }
1663
1664
1665 static int wlan_set_genie(struct net_device *dev,
1666                           struct iw_request_info *info,
1667                           struct iw_point *dwrq,
1668                           char *extra)
1669 {
1670         wlan_private *priv = dev->priv;
1671         wlan_adapter *adapter = priv->adapter;
1672         int ret = 0;
1673         struct assoc_request * assoc_req;
1674
1675         lbs_deb_enter(LBS_DEB_WEXT);
1676
1677         mutex_lock(&adapter->lock);
1678         assoc_req = wlan_get_association_request(adapter);
1679         if (!assoc_req) {
1680                 ret = -ENOMEM;
1681                 goto out;
1682         }
1683
1684         if (dwrq->length > MAX_WPA_IE_LEN ||
1685             (dwrq->length && extra == NULL)) {
1686                 ret = -EINVAL;
1687                 goto out;
1688         }
1689
1690         if (dwrq->length) {
1691                 memcpy(&assoc_req->wpa_ie[0], extra, dwrq->length);
1692                 assoc_req->wpa_ie_len = dwrq->length;
1693         } else {
1694                 memset(&assoc_req->wpa_ie[0], 0, sizeof(adapter->wpa_ie));
1695                 assoc_req->wpa_ie_len = 0;
1696         }
1697
1698 out:
1699         if (ret == 0) {
1700                 set_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags);
1701                 wlan_postpone_association_work(priv);
1702         } else {
1703                 wlan_cancel_association_work(priv);
1704         }
1705         mutex_unlock(&adapter->lock);
1706
1707         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1708         return ret;
1709 }
1710
1711 static int wlan_get_genie(struct net_device *dev,
1712                           struct iw_request_info *info,
1713                           struct iw_point *dwrq,
1714                           char *extra)
1715 {
1716         int ret = 0;
1717         wlan_private *priv = dev->priv;
1718         wlan_adapter *adapter = priv->adapter;
1719
1720         lbs_deb_enter(LBS_DEB_WEXT);
1721
1722         if (adapter->wpa_ie_len == 0) {
1723                 dwrq->length = 0;
1724                 goto out;
1725         }
1726
1727         if (dwrq->length < adapter->wpa_ie_len) {
1728                 ret = -E2BIG;
1729                 goto out;
1730         }
1731
1732         dwrq->length = adapter->wpa_ie_len;
1733         memcpy(extra, &adapter->wpa_ie[0], adapter->wpa_ie_len);
1734
1735 out:
1736         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1737         return ret;
1738 }
1739
1740
1741 static int wlan_set_auth(struct net_device *dev,
1742                          struct iw_request_info *info,
1743                          struct iw_param *dwrq,
1744                          char *extra)
1745 {
1746         wlan_private *priv = dev->priv;
1747         wlan_adapter *adapter = priv->adapter;
1748         struct assoc_request * assoc_req;
1749         int ret = 0;
1750         int updated = 0;
1751
1752         lbs_deb_enter(LBS_DEB_WEXT);
1753
1754         mutex_lock(&adapter->lock);
1755         assoc_req = wlan_get_association_request(adapter);
1756         if (!assoc_req) {
1757                 ret = -ENOMEM;
1758                 goto out;
1759         }
1760
1761         switch (dwrq->flags & IW_AUTH_INDEX) {
1762         case IW_AUTH_TKIP_COUNTERMEASURES:
1763         case IW_AUTH_CIPHER_PAIRWISE:
1764         case IW_AUTH_CIPHER_GROUP:
1765         case IW_AUTH_KEY_MGMT:
1766         case IW_AUTH_DROP_UNENCRYPTED:
1767                 /*
1768                  * libertas does not use these parameters
1769                  */
1770                 break;
1771
1772         case IW_AUTH_WPA_VERSION:
1773                 if (dwrq->value & IW_AUTH_WPA_VERSION_DISABLED) {
1774                         assoc_req->secinfo.WPAenabled = 0;
1775                         assoc_req->secinfo.WPA2enabled = 0;
1776                         disable_wpa (assoc_req);
1777                 }
1778                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA) {
1779                         assoc_req->secinfo.WPAenabled = 1;
1780                         assoc_req->secinfo.wep_enabled = 0;
1781                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1782                 }
1783                 if (dwrq->value & IW_AUTH_WPA_VERSION_WPA2) {
1784                         assoc_req->secinfo.WPA2enabled = 1;
1785                         assoc_req->secinfo.wep_enabled = 0;
1786                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1787                 }
1788                 updated = 1;
1789                 break;
1790
1791         case IW_AUTH_80211_AUTH_ALG:
1792                 if (dwrq->value & IW_AUTH_ALG_SHARED_KEY) {
1793                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_SHARED_KEY;
1794                 } else if (dwrq->value & IW_AUTH_ALG_OPEN_SYSTEM) {
1795                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1796                 } else if (dwrq->value & IW_AUTH_ALG_LEAP) {
1797                         assoc_req->secinfo.auth_mode = IW_AUTH_ALG_LEAP;
1798                 } else {
1799                         ret = -EINVAL;
1800                 }
1801                 updated = 1;
1802                 break;
1803
1804         case IW_AUTH_WPA_ENABLED:
1805                 if (dwrq->value) {
1806                         if (!assoc_req->secinfo.WPAenabled &&
1807                             !assoc_req->secinfo.WPA2enabled) {
1808                                 assoc_req->secinfo.WPAenabled = 1;
1809                                 assoc_req->secinfo.WPA2enabled = 1;
1810                                 assoc_req->secinfo.wep_enabled = 0;
1811                                 assoc_req->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1812                         }
1813                 } else {
1814                         assoc_req->secinfo.WPAenabled = 0;
1815                         assoc_req->secinfo.WPA2enabled = 0;
1816                         disable_wpa (assoc_req);
1817                 }
1818                 updated = 1;
1819                 break;
1820
1821         default:
1822                 ret = -EOPNOTSUPP;
1823                 break;
1824         }
1825
1826 out:
1827         if (ret == 0) {
1828                 if (updated)
1829                         set_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags);
1830                 wlan_postpone_association_work(priv);
1831         } else if (ret != -EOPNOTSUPP) {
1832                 wlan_cancel_association_work(priv);
1833         }
1834         mutex_unlock(&adapter->lock);
1835
1836         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1837         return ret;
1838 }
1839
1840 static int wlan_get_auth(struct net_device *dev,
1841                          struct iw_request_info *info,
1842                          struct iw_param *dwrq,
1843                          char *extra)
1844 {
1845         int ret = 0;
1846         wlan_private *priv = dev->priv;
1847         wlan_adapter *adapter = priv->adapter;
1848
1849         lbs_deb_enter(LBS_DEB_WEXT);
1850
1851         switch (dwrq->flags & IW_AUTH_INDEX) {
1852         case IW_AUTH_WPA_VERSION:
1853                 dwrq->value = 0;
1854                 if (adapter->secinfo.WPAenabled)
1855                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA;
1856                 if (adapter->secinfo.WPA2enabled)
1857                         dwrq->value |= IW_AUTH_WPA_VERSION_WPA2;
1858                 if (!dwrq->value)
1859                         dwrq->value |= IW_AUTH_WPA_VERSION_DISABLED;
1860                 break;
1861
1862         case IW_AUTH_80211_AUTH_ALG:
1863                 dwrq->value = adapter->secinfo.auth_mode;
1864                 break;
1865
1866         case IW_AUTH_WPA_ENABLED:
1867                 if (adapter->secinfo.WPAenabled && adapter->secinfo.WPA2enabled)
1868                         dwrq->value = 1;
1869                 break;
1870
1871         default:
1872                 ret = -EOPNOTSUPP;
1873         }
1874
1875         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1876         return ret;
1877 }
1878
1879
1880 static int wlan_set_txpow(struct net_device *dev, struct iw_request_info *info,
1881                    struct iw_param *vwrq, char *extra)
1882 {
1883         int ret = 0;
1884         wlan_private *priv = dev->priv;
1885         wlan_adapter *adapter = priv->adapter;
1886
1887         u16 dbm;
1888
1889         lbs_deb_enter(LBS_DEB_WEXT);
1890
1891         if (vwrq->disabled) {
1892                 wlan_radio_ioctl(priv, RADIO_OFF);
1893                 return 0;
1894         }
1895
1896         adapter->preamble = CMD_TYPE_AUTO_PREAMBLE;
1897
1898         wlan_radio_ioctl(priv, RADIO_ON);
1899
1900         if ((vwrq->flags & IW_TXPOW_TYPE) == IW_TXPOW_MWATT) {
1901                 dbm = (u16) mw_to_dbm(vwrq->value);
1902         } else
1903                 dbm = (u16) vwrq->value;
1904
1905         /* auto tx power control */
1906
1907         if (vwrq->fixed == 0)
1908                 dbm = 0xffff;
1909
1910         lbs_deb_wext("txpower set %d dbm\n", dbm);
1911
1912         ret = libertas_prepare_and_send_command(priv,
1913                                     CMD_802_11_RF_TX_POWER,
1914                                     CMD_ACT_TX_POWER_OPT_SET_LOW,
1915                                     CMD_OPTION_WAITFORRSP, 0, (void *)&dbm);
1916
1917         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
1918         return ret;
1919 }
1920
1921 static int wlan_get_essid(struct net_device *dev, struct iw_request_info *info,
1922                    struct iw_point *dwrq, char *extra)
1923 {
1924         wlan_private *priv = dev->priv;
1925         wlan_adapter *adapter = priv->adapter;
1926
1927         lbs_deb_enter(LBS_DEB_WEXT);
1928
1929         /*
1930          * Note : if dwrq->flags != 0, we should get the relevant SSID from
1931          * the SSID list...
1932          */
1933
1934         /*
1935          * Get the current SSID
1936          */
1937         if (adapter->connect_status == LIBERTAS_CONNECTED) {
1938                 memcpy(extra, adapter->curbssparams.ssid,
1939                        adapter->curbssparams.ssid_len);
1940                 extra[adapter->curbssparams.ssid_len] = '\0';
1941         } else {
1942                 memset(extra, 0, 32);
1943                 extra[adapter->curbssparams.ssid_len] = '\0';
1944         }
1945         /*
1946          * If none, we may want to get the one that was set
1947          */
1948
1949         /* To make the driver backward compatible with WPA supplicant v0.2.4 */
1950         if (dwrq->length == 32) /* check with WPA supplicant buffer size */
1951                 dwrq->length = min_t(size_t, adapter->curbssparams.ssid_len,
1952                                    IW_ESSID_MAX_SIZE);
1953         else
1954                 dwrq->length = adapter->curbssparams.ssid_len + 1;
1955
1956         dwrq->flags = 1;        /* active */
1957
1958         lbs_deb_leave(LBS_DEB_WEXT);
1959         return 0;
1960 }
1961
1962 static int wlan_set_essid(struct net_device *dev, struct iw_request_info *info,
1963                    struct iw_point *dwrq, char *extra)
1964 {
1965         wlan_private *priv = dev->priv;
1966         wlan_adapter *adapter = priv->adapter;
1967         int ret = 0;
1968         u8 ssid[IW_ESSID_MAX_SIZE];
1969         u8 ssid_len = 0;
1970         struct assoc_request * assoc_req;
1971         int in_ssid_len = dwrq->length;
1972
1973         lbs_deb_enter(LBS_DEB_WEXT);
1974
1975         /*
1976          * WE-20 and earlier NULL pad the end of the SSID and increment
1977          * SSID length so it can be used like a string.  WE-21 and later don't,
1978          * but some userspace tools aren't able to cope with the change.
1979          */
1980         if ((in_ssid_len > 0) && (extra[in_ssid_len - 1] == '\0'))
1981                 in_ssid_len--;
1982
1983         /* Check the size of the string */
1984         if (in_ssid_len > IW_ESSID_MAX_SIZE) {
1985                 ret = -E2BIG;
1986                 goto out;
1987         }
1988
1989         memset(&ssid, 0, sizeof(ssid));
1990
1991         if (!dwrq->flags || !in_ssid_len) {
1992                 /* "any" SSID requested; leave SSID blank */
1993         } else {
1994                 /* Specific SSID requested */
1995                 memcpy(&ssid, extra, in_ssid_len);
1996                 ssid_len = in_ssid_len;
1997         }
1998
1999         if (!ssid_len) {
2000                 lbs_deb_wext("requested any SSID\n");
2001         } else {
2002                 lbs_deb_wext("requested SSID '%s'\n",
2003                              escape_essid(ssid, ssid_len));
2004         }
2005
2006 out:
2007         mutex_lock(&adapter->lock);
2008         if (ret == 0) {
2009                 /* Get or create the current association request */
2010                 assoc_req = wlan_get_association_request(adapter);
2011                 if (!assoc_req) {
2012                         ret = -ENOMEM;
2013                 } else {
2014                         /* Copy the SSID to the association request */
2015                         memcpy(&assoc_req->ssid, &ssid, IW_ESSID_MAX_SIZE);
2016                         assoc_req->ssid_len = ssid_len;
2017                         set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
2018                         wlan_postpone_association_work(priv);
2019                 }
2020         }
2021
2022         /* Cancel the association request if there was an error */
2023         if (ret != 0) {
2024                 wlan_cancel_association_work(priv);
2025         }
2026
2027         mutex_unlock(&adapter->lock);
2028
2029         lbs_deb_leave_args(LBS_DEB_WEXT, "ret %d", ret);
2030         return ret;
2031 }
2032
2033 /**
2034  *  @brief Connect to the AP or Ad-hoc Network with specific bssid
2035  *
2036  *  @param dev          A pointer to net_device structure
2037  *  @param info         A pointer to iw_request_info structure
2038  *  @param awrq         A pointer to iw_param structure
2039  *  @param extra        A pointer to extra data buf
2040  *  @return             0 --success, otherwise fail
2041  */
2042 static int wlan_set_wap(struct net_device *dev, struct iw_request_info *info,
2043                  struct sockaddr *awrq, char *extra)
2044 {
2045         wlan_private *priv = dev->priv;
2046         wlan_adapter *adapter = priv->adapter;
2047         struct assoc_request * assoc_req;
2048         int ret = 0;
2049
2050         lbs_deb_enter(LBS_DEB_WEXT);
2051
2052         if (awrq->sa_family != ARPHRD_ETHER)
2053                 return -EINVAL;
2054
2055         lbs_deb_wext("ASSOC: WAP: sa_data " MAC_FMT "\n", MAC_ARG(awrq->sa_data));
2056
2057         mutex_lock(&adapter->lock);
2058
2059         /* Get or create the current association request */
2060         assoc_req = wlan_get_association_request(adapter);
2061         if (!assoc_req) {
2062                 wlan_cancel_association_work(priv);
2063                 ret = -ENOMEM;
2064         } else {
2065                 /* Copy the BSSID to the association request */
2066                 memcpy(&assoc_req->bssid, awrq->sa_data, ETH_ALEN);
2067                 set_bit(ASSOC_FLAG_BSSID, &assoc_req->flags);
2068                 wlan_postpone_association_work(priv);
2069         }
2070
2071         mutex_unlock(&adapter->lock);
2072
2073         return ret;
2074 }
2075
2076 void libertas_get_fwversion(wlan_adapter * adapter, char *fwversion, int maxlen)
2077 {
2078         char fwver[32];
2079
2080         mutex_lock(&adapter->lock);
2081
2082         if (adapter->fwreleasenumber[3] == 0)
2083                 sprintf(fwver, "%u.%u.%u",
2084                         adapter->fwreleasenumber[2],
2085                         adapter->fwreleasenumber[1],
2086                         adapter->fwreleasenumber[0]);
2087         else
2088                 sprintf(fwver, "%u.%u.%u.p%u",
2089                         adapter->fwreleasenumber[2],
2090                         adapter->fwreleasenumber[1],
2091                         adapter->fwreleasenumber[0],
2092                         adapter->fwreleasenumber[3]);
2093
2094         mutex_unlock(&adapter->lock);
2095         snprintf(fwversion, maxlen, fwver);
2096 }
2097
2098
2099 /*
2100  * iwconfig settable callbacks
2101  */
2102 static const iw_handler wlan_handler[] = {
2103         (iw_handler) NULL,      /* SIOCSIWCOMMIT */
2104         (iw_handler) wlan_get_name,     /* SIOCGIWNAME */
2105         (iw_handler) NULL,      /* SIOCSIWNWID */
2106         (iw_handler) NULL,      /* SIOCGIWNWID */
2107         (iw_handler) wlan_set_freq,     /* SIOCSIWFREQ */
2108         (iw_handler) wlan_get_freq,     /* SIOCGIWFREQ */
2109         (iw_handler) wlan_set_mode,     /* SIOCSIWMODE */
2110         (iw_handler) wlan_get_mode,     /* SIOCGIWMODE */
2111         (iw_handler) NULL,      /* SIOCSIWSENS */
2112         (iw_handler) NULL,      /* SIOCGIWSENS */
2113         (iw_handler) NULL,      /* SIOCSIWRANGE */
2114         (iw_handler) wlan_get_range,    /* SIOCGIWRANGE */
2115         (iw_handler) NULL,      /* SIOCSIWPRIV */
2116         (iw_handler) NULL,      /* SIOCGIWPRIV */
2117         (iw_handler) NULL,      /* SIOCSIWSTATS */
2118         (iw_handler) NULL,      /* SIOCGIWSTATS */
2119         iw_handler_set_spy,     /* SIOCSIWSPY */
2120         iw_handler_get_spy,     /* SIOCGIWSPY */
2121         iw_handler_set_thrspy,  /* SIOCSIWTHRSPY */
2122         iw_handler_get_thrspy,  /* SIOCGIWTHRSPY */
2123         (iw_handler) wlan_set_wap,      /* SIOCSIWAP */
2124         (iw_handler) wlan_get_wap,      /* SIOCGIWAP */
2125         (iw_handler) NULL,      /* SIOCSIWMLME */
2126         (iw_handler) NULL,      /* SIOCGIWAPLIST - deprecated */
2127         (iw_handler) libertas_set_scan, /* SIOCSIWSCAN */
2128         (iw_handler) libertas_get_scan, /* SIOCGIWSCAN */
2129         (iw_handler) wlan_set_essid,    /* SIOCSIWESSID */
2130         (iw_handler) wlan_get_essid,    /* SIOCGIWESSID */
2131         (iw_handler) wlan_set_nick,     /* SIOCSIWNICKN */
2132         (iw_handler) wlan_get_nick,     /* SIOCGIWNICKN */
2133         (iw_handler) NULL,      /* -- hole -- */
2134         (iw_handler) NULL,      /* -- hole -- */
2135         (iw_handler) wlan_set_rate,     /* SIOCSIWRATE */
2136         (iw_handler) wlan_get_rate,     /* SIOCGIWRATE */
2137         (iw_handler) wlan_set_rts,      /* SIOCSIWRTS */
2138         (iw_handler) wlan_get_rts,      /* SIOCGIWRTS */
2139         (iw_handler) wlan_set_frag,     /* SIOCSIWFRAG */
2140         (iw_handler) wlan_get_frag,     /* SIOCGIWFRAG */
2141         (iw_handler) wlan_set_txpow,    /* SIOCSIWTXPOW */
2142         (iw_handler) wlan_get_txpow,    /* SIOCGIWTXPOW */
2143         (iw_handler) wlan_set_retry,    /* SIOCSIWRETRY */
2144         (iw_handler) wlan_get_retry,    /* SIOCGIWRETRY */
2145         (iw_handler) wlan_set_encode,   /* SIOCSIWENCODE */
2146         (iw_handler) wlan_get_encode,   /* SIOCGIWENCODE */
2147         (iw_handler) wlan_set_power,    /* SIOCSIWPOWER */
2148         (iw_handler) wlan_get_power,    /* SIOCGIWPOWER */
2149         (iw_handler) NULL,      /* -- hole -- */
2150         (iw_handler) NULL,      /* -- hole -- */
2151         (iw_handler) wlan_set_genie,    /* SIOCSIWGENIE */
2152         (iw_handler) wlan_get_genie,    /* SIOCGIWGENIE */
2153         (iw_handler) wlan_set_auth,     /* SIOCSIWAUTH */
2154         (iw_handler) wlan_get_auth,     /* SIOCGIWAUTH */
2155         (iw_handler) wlan_set_encodeext,/* SIOCSIWENCODEEXT */
2156         (iw_handler) wlan_get_encodeext,/* SIOCGIWENCODEEXT */
2157         (iw_handler) NULL,              /* SIOCSIWPMKSA */
2158 };
2159
2160 static const iw_handler mesh_wlan_handler[] = {
2161         (iw_handler) NULL,      /* SIOCSIWCOMMIT */
2162         (iw_handler) wlan_get_name,     /* SIOCGIWNAME */
2163         (iw_handler) NULL,      /* SIOCSIWNWID */
2164         (iw_handler) NULL,      /* SIOCGIWNWID */
2165         (iw_handler) wlan_set_freq,     /* SIOCSIWFREQ */
2166         (iw_handler) wlan_get_freq,     /* SIOCGIWFREQ */
2167         (iw_handler) NULL,              /* SIOCSIWMODE */
2168         (iw_handler) mesh_wlan_get_mode,        /* SIOCGIWMODE */
2169         (iw_handler) NULL,      /* SIOCSIWSENS */
2170         (iw_handler) NULL,      /* SIOCGIWSENS */
2171         (iw_handler) NULL,      /* SIOCSIWRANGE */
2172         (iw_handler) wlan_get_range,    /* SIOCGIWRANGE */
2173         (iw_handler) NULL,      /* SIOCSIWPRIV */
2174         (iw_handler) NULL,      /* SIOCGIWPRIV */
2175         (iw_handler) NULL,      /* SIOCSIWSTATS */
2176         (iw_handler) NULL,      /* SIOCGIWSTATS */
2177         iw_handler_set_spy,     /* SIOCSIWSPY */
2178         iw_handler_get_spy,     /* SIOCGIWSPY */
2179         iw_handler_set_thrspy,  /* SIOCSIWTHRSPY */
2180         iw_handler_get_thrspy,  /* SIOCGIWTHRSPY */
2181         (iw_handler) NULL,      /* SIOCSIWAP */
2182         (iw_handler) NULL,      /* SIOCGIWAP */
2183         (iw_handler) NULL,      /* SIOCSIWMLME */
2184         (iw_handler) NULL,      /* SIOCGIWAPLIST - deprecated */
2185         (iw_handler) libertas_set_scan, /* SIOCSIWSCAN */
2186         (iw_handler) libertas_get_scan, /* SIOCGIWSCAN */
2187         (iw_handler) NULL,              /* SIOCSIWESSID */
2188         (iw_handler) NULL,              /* SIOCGIWESSID */
2189         (iw_handler) NULL,              /* SIOCSIWNICKN */
2190         (iw_handler) mesh_get_nick,     /* SIOCGIWNICKN */
2191         (iw_handler) NULL,      /* -- hole -- */
2192         (iw_handler) NULL,      /* -- hole -- */
2193         (iw_handler) wlan_set_rate,     /* SIOCSIWRATE */
2194         (iw_handler) wlan_get_rate,     /* SIOCGIWRATE */
2195         (iw_handler) wlan_set_rts,      /* SIOCSIWRTS */
2196         (iw_handler) wlan_get_rts,      /* SIOCGIWRTS */
2197         (iw_handler) wlan_set_frag,     /* SIOCSIWFRAG */
2198         (iw_handler) wlan_get_frag,     /* SIOCGIWFRAG */
2199         (iw_handler) wlan_set_txpow,    /* SIOCSIWTXPOW */
2200         (iw_handler) wlan_get_txpow,    /* SIOCGIWTXPOW */
2201         (iw_handler) wlan_set_retry,    /* SIOCSIWRETRY */
2202         (iw_handler) wlan_get_retry,    /* SIOCGIWRETRY */
2203         (iw_handler) wlan_set_encode,   /* SIOCSIWENCODE */
2204         (iw_handler) wlan_get_encode,   /* SIOCGIWENCODE */
2205         (iw_handler) wlan_set_power,    /* SIOCSIWPOWER */
2206         (iw_handler) wlan_get_power,    /* SIOCGIWPOWER */
2207         (iw_handler) NULL,      /* -- hole -- */
2208         (iw_handler) NULL,      /* -- hole -- */
2209         (iw_handler) wlan_set_genie,    /* SIOCSIWGENIE */
2210         (iw_handler) wlan_get_genie,    /* SIOCGIWGENIE */
2211         (iw_handler) wlan_set_auth,     /* SIOCSIWAUTH */
2212         (iw_handler) wlan_get_auth,     /* SIOCGIWAUTH */
2213         (iw_handler) wlan_set_encodeext,/* SIOCSIWENCODEEXT */
2214         (iw_handler) wlan_get_encodeext,/* SIOCGIWENCODEEXT */
2215         (iw_handler) NULL,              /* SIOCSIWPMKSA */
2216 };
2217 struct iw_handler_def libertas_handler_def = {
2218         .num_standard   = sizeof(wlan_handler) / sizeof(iw_handler),
2219         .standard       = (iw_handler *) wlan_handler,
2220         .get_wireless_stats = wlan_get_wireless_stats,
2221 };
2222
2223 struct iw_handler_def mesh_handler_def = {
2224         .num_standard   = sizeof(mesh_wlan_handler) / sizeof(iw_handler),
2225         .standard       = (iw_handler *) mesh_wlan_handler,
2226         .get_wireless_stats = wlan_get_wireless_stats,
2227 };