SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/wireless/orinoco/wext.c

   1 /* Wireless extensions support.
   2  *
   3  * See copyright notice in main.c
   4  */
   5 #include <linux/slab.h>
   6 #include <linux/kernel.h>
   7 #include <linux/if_arp.h>
   8 #include <linux/wireless.h>
   9 #include <linux/ieee80211.h>
  10 #include <net/iw_handler.h>
  11 #include <net/cfg80211.h>
  12
  13 #include "hermes.h"
  14 #include "hermes_rid.h"
  15 #include "orinoco.h"
  16
  17 #include "hw.h"
  18 #include "mic.h"
  19 #include "scan.h"
  20 #include "main.h"
  21
  22 #include "wext.h"
  23
  24 #define MAX_RID_LEN 1024
  25
  26 /* Helper routine to record keys
  27  * It is called under orinoco_lock so it may not sleep */
  28 static int orinoco_set_key(struct orinoco_private *priv, int index,
  29                            enum orinoco_alg alg, const u8 *key, int key_len,
  30                            const u8 *seq, int seq_len)
  31 {
  32         kzfree(priv->keys[index].key);
  33         kzfree(priv->keys[index].seq);
  34
  35         if (key_len) {
  36                 priv->keys[index].key = kzalloc(key_len, GFP_ATOMIC);
  37                 if (!priv->keys[index].key)
  38                         goto nomem;
  39         } else
  40                 priv->keys[index].key = NULL;
  41
  42         if (seq_len) {
  43                 priv->keys[index].seq = kzalloc(seq_len, GFP_ATOMIC);
  44                 if (!priv->keys[index].seq)
  45                         goto free_key;
  46         } else
  47                 priv->keys[index].seq = NULL;
  48
  49         priv->keys[index].key_len = key_len;
  50         priv->keys[index].seq_len = seq_len;
  51
  52         if (key_len)
  53                 memcpy(priv->keys[index].key, key, key_len);
  54         if (seq_len)
  55                 memcpy(priv->keys[index].seq, seq, seq_len);
  56
  57         switch (alg) {
  58         case ORINOCO_ALG_TKIP:
  59                 priv->keys[index].cipher = WLAN_CIPHER_SUITE_TKIP;
  60                 break;
  61
  62         case ORINOCO_ALG_WEP:
  63                 priv->keys[index].cipher = (key_len > SMALL_KEY_SIZE) ?
  64                         WLAN_CIPHER_SUITE_WEP104 : WLAN_CIPHER_SUITE_WEP40;
  65                 break;
  66
  67         case ORINOCO_ALG_NONE:
  68         default:
  69                 priv->keys[index].cipher = 0;
  70                 break;
  71         }
  72
  73         return 0;
  74
  75 free_key:
  76         kfree(priv->keys[index].key);
  77         priv->keys[index].key = NULL;
  78
  79 nomem:
  80         priv->keys[index].key_len = 0;
  81         priv->keys[index].seq_len = 0;
  82         priv->keys[index].cipher = 0;
  83
  84         return -ENOMEM;
  85 }
  86
  87 static struct iw_statistics *orinoco_get_wireless_stats(struct net_device *dev)
  88 {
  89         struct orinoco_private *priv = ndev_priv(dev);
  90         hermes_t *hw = &priv->hw;
  91         struct iw_statistics *wstats = &priv->wstats;
  92         int err;
  93         unsigned long flags;
  94
  95         if (!netif_device_present(dev)) {
  96                 printk(KERN_WARNING "%s: get_wireless_stats() called while device not present\n",
  97                        dev->name);
  98                 return NULL; /* FIXME: Can we do better than this? */
  99         }
 100
 101         /* If busy, return the old stats.  Returning NULL may cause
 102          * the interface to disappear from /proc/net/wireless */
 103         if (orinoco_lock(priv, &flags) != 0)
 104                 return wstats;
 105
 106         /* We can't really wait for the tallies inquiry command to
 107          * complete, so we just use the previous results and trigger
 108          * a new tallies inquiry command for next time - Jean II */
 109         /* FIXME: Really we should wait for the inquiry to come back -
 110          * as it is the stats we give don't make a whole lot of sense.
 111          * Unfortunately, it's not clear how to do that within the
 112          * wireless extensions framework: I think we're in user
 113          * context, but a lock seems to be held by the time we get in
 114          * here so we're not safe to sleep here. */
 115         hermes_inquire(hw, HERMES_INQ_TALLIES);
 116
 117         if (priv->iw_mode == NL80211_IFTYPE_ADHOC) {
 118                 memset(&wstats->qual, 0, sizeof(wstats->qual));
 119                 /* If a spy address is defined, we report stats of the
 120                  * first spy address - Jean II */
 121                 if (SPY_NUMBER(priv)) {
 122                         wstats->qual.qual = priv->spy_data.spy_stat[0].qual;
 123                         wstats->qual.level = priv->spy_data.spy_stat[0].level;
 124                         wstats->qual.noise = priv->spy_data.spy_stat[0].noise;
 125                         wstats->qual.updated =
 126                                 priv->spy_data.spy_stat[0].updated;
 127                 }
 128         } else {
 129                 struct {
 130                         __le16 qual, signal, noise, unused;
 131                 } __attribute__ ((packed)) cq;
 132
 133                 err = HERMES_READ_RECORD(hw, USER_BAP,
 134                                          HERMES_RID_COMMSQUALITY, &cq);
 135
 136                 if (!err) {
 137                         wstats->qual.qual = (int)le16_to_cpu(cq.qual);
 138                         wstats->qual.level = (int)le16_to_cpu(cq.signal) - 0x95;
 139                         wstats->qual.noise = (int)le16_to_cpu(cq.noise) - 0x95;
 140                         wstats->qual.updated =
 141                                 IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 142                 }
 143         }
 144
 145         orinoco_unlock(priv, &flags);
 146         return wstats;
 147 }
 148
 149 /********************************************************************/
 150 /* Wireless extensions                                              */
 151 /********************************************************************/
 152
 153 static int orinoco_ioctl_setwap(struct net_device *dev,
 154                                 struct iw_request_info *info,
 155                                 struct sockaddr *ap_addr,
 156                                 char *extra)
 157 {
 158         struct orinoco_private *priv = ndev_priv(dev);
 159         int err = -EINPROGRESS;         /* Call commit handler */
 160         unsigned long flags;
 161         static const u8 off_addr[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 162         static const u8 any_addr[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 163
 164         if (orinoco_lock(priv, &flags) != 0)
 165                 return -EBUSY;
 166
 167         /* Enable automatic roaming - no sanity checks are needed */
 168         if (memcmp(&ap_addr->sa_data, off_addr, ETH_ALEN) == 0 ||
 169             memcmp(&ap_addr->sa_data, any_addr, ETH_ALEN) == 0) {
 170                 priv->bssid_fixed = 0;
 171                 memset(priv->desired_bssid, 0, ETH_ALEN);
 172
 173                 /* "off" means keep existing connection */
 174                 if (ap_addr->sa_data[0] == 0) {
 175                         __orinoco_hw_set_wap(priv);
 176                         err = 0;
 177                 }
 178                 goto out;
 179         }
 180
 181         if (priv->firmware_type == FIRMWARE_TYPE_AGERE) {
 182                 printk(KERN_WARNING "%s: Lucent/Agere firmware doesn't "
 183                        "support manual roaming\n",
 184                        dev->name);
 185                 err = -EOPNOTSUPP;
 186                 goto out;
 187         }
 188
 189         if (priv->iw_mode != NL80211_IFTYPE_STATION) {
 190                 printk(KERN_WARNING "%s: Manual roaming supported only in "
 191                        "managed mode\n", dev->name);
 192                 err = -EOPNOTSUPP;
 193                 goto out;
 194         }
 195
 196         /* Intersil firmware hangs without Desired ESSID */
 197         if (priv->firmware_type == FIRMWARE_TYPE_INTERSIL &&
 198             strlen(priv->desired_essid) == 0) {
 199                 printk(KERN_WARNING "%s: Desired ESSID must be set for "
 200                        "manual roaming\n", dev->name);
 201                 err = -EOPNOTSUPP;
 202                 goto out;
 203         }
 204
 205         /* Finally, enable manual roaming */
 206         priv->bssid_fixed = 1;
 207         memcpy(priv->desired_bssid, &ap_addr->sa_data, ETH_ALEN);
 208
 209  out:
 210         orinoco_unlock(priv, &flags);
 211         return err;
 212 }
 213
 214 static int orinoco_ioctl_getwap(struct net_device *dev,
 215                                 struct iw_request_info *info,
 216                                 struct sockaddr *ap_addr,
 217                                 char *extra)
 218 {
 219         struct orinoco_private *priv = ndev_priv(dev);
 220
 221         int err = 0;
 222         unsigned long flags;
 223
 224         if (orinoco_lock(priv, &flags) != 0)
 225                 return -EBUSY;
 226
 227         ap_addr->sa_family = ARPHRD_ETHER;
 228         err = orinoco_hw_get_current_bssid(priv, ap_addr->sa_data);
 229
 230         orinoco_unlock(priv, &flags);
 231
 232         return err;
 233 }
 234
 235 static int orinoco_ioctl_setiwencode(struct net_device *dev,
 236                                      struct iw_request_info *info,
 237                                      struct iw_point *erq,
 238                                      char *keybuf)
 239 {
 240         struct orinoco_private *priv = ndev_priv(dev);
 241         int index = (erq->flags & IW_ENCODE_INDEX) - 1;
 242         int setindex = priv->tx_key;
 243         enum orinoco_alg encode_alg = priv->encode_alg;
 244         int restricted = priv->wep_restrict;
 245         int err = -EINPROGRESS;         /* Call commit handler */
 246         unsigned long flags;
 247
 248         if (!priv->has_wep)
 249                 return -EOPNOTSUPP;
 250
 251         if (erq->pointer) {
 252                 /* We actually have a key to set - check its length */
 253                 if (erq->length > LARGE_KEY_SIZE)
 254                         return -E2BIG;
 255
 256                 if ((erq->length > SMALL_KEY_SIZE) && !priv->has_big_wep)
 257                         return -E2BIG;
 258         }
 259
 260         if (orinoco_lock(priv, &flags) != 0)
 261                 return -EBUSY;
 262
 263         /* Clear any TKIP key we have */
 264         if ((priv->has_wpa) && (priv->encode_alg == ORINOCO_ALG_TKIP))
 265                 (void) orinoco_clear_tkip_key(priv, setindex);
 266
 267         if (erq->length > 0) {
 268                 if ((index < 0) || (index >= ORINOCO_MAX_KEYS))
 269                         index = priv->tx_key;
 270
 271                 /* Switch on WEP if off */
 272                 if (encode_alg != ORINOCO_ALG_WEP) {
 273                         setindex = index;
 274                         encode_alg = ORINOCO_ALG_WEP;
 275                 }
 276         } else {
 277                 /* Important note : if the user do "iwconfig eth0 enc off",
 278                  * we will arrive there with an index of -1. This is valid
 279                  * but need to be taken care off... Jean II */
 280                 if ((index < 0) || (index >= ORINOCO_MAX_KEYS)) {
 281                         if ((index != -1) || (erq->flags == 0)) {
 282                                 err = -EINVAL;
 283                                 goto out;
 284                         }
 285                 } else {
 286                         /* Set the index : Check that the key is valid */
 287                         if (priv->keys[index].key_len == 0) {
 288                                 err = -EINVAL;
 289                                 goto out;
 290                         }
 291                         setindex = index;
 292                 }
 293         }
 294
 295         if (erq->flags & IW_ENCODE_DISABLED)
 296                 encode_alg = ORINOCO_ALG_NONE;
 297         if (erq->flags & IW_ENCODE_OPEN)
 298                 restricted = 0;
 299         if (erq->flags & IW_ENCODE_RESTRICTED)
 300                 restricted = 1;
 301
 302         if (erq->pointer && erq->length > 0) {
 303                 err = orinoco_set_key(priv, index, ORINOCO_ALG_WEP, keybuf,
 304                                       erq->length, NULL, 0);
 305         }
 306         priv->tx_key = setindex;
 307
 308         /* Try fast key change if connected and only keys are changed */
 309         if ((priv->encode_alg == encode_alg) &&
 310             (priv->wep_restrict == restricted) &&
 311             netif_carrier_ok(dev)) {
 312                 err = __orinoco_hw_setup_wepkeys(priv);
 313                 /* No need to commit if successful */
 314                 goto out;
 315         }
 316
 317         priv->encode_alg = encode_alg;
 318         priv->wep_restrict = restricted;
 319
 320  out:
 321         orinoco_unlock(priv, &flags);
 322
 323         return err;
 324 }
 325
 326 static int orinoco_ioctl_getiwencode(struct net_device *dev,
 327                                      struct iw_request_info *info,
 328                                      struct iw_point *erq,
 329                                      char *keybuf)
 330 {
 331         struct orinoco_private *priv = ndev_priv(dev);
 332         int index = (erq->flags & IW_ENCODE_INDEX) - 1;
 333         unsigned long flags;
 334
 335         if (!priv->has_wep)
 336                 return -EOPNOTSUPP;
 337
 338         if (orinoco_lock(priv, &flags) != 0)
 339                 return -EBUSY;
 340
 341         if ((index < 0) || (index >= ORINOCO_MAX_KEYS))
 342                 index = priv->tx_key;
 343
 344         erq->flags = 0;
 345         if (!priv->encode_alg)
 346                 erq->flags |= IW_ENCODE_DISABLED;
 347         erq->flags |= index + 1;
 348
 349         if (priv->wep_restrict)
 350                 erq->flags |= IW_ENCODE_RESTRICTED;
 351         else
 352                 erq->flags |= IW_ENCODE_OPEN;
 353
 354         erq->length = priv->keys[index].key_len;
 355
 356         memcpy(keybuf, priv->keys[index].key, erq->length);
 357
 358         orinoco_unlock(priv, &flags);
 359         return 0;
 360 }
 361
 362 static int orinoco_ioctl_setessid(struct net_device *dev,
 363                                   struct iw_request_info *info,
 364                                   struct iw_point *erq,
 365                                   char *essidbuf)
 366 {
 367         struct orinoco_private *priv = ndev_priv(dev);
 368         unsigned long flags;
 369
 370         /* Note : ESSID is ignored in Ad-Hoc demo mode, but we can set it
 371          * anyway... - Jean II */
 372
 373         /* Hum... Should not use Wireless Extension constant (may change),
 374          * should use our own... - Jean II */
 375         if (erq->length > IW_ESSID_MAX_SIZE)
 376                 return -E2BIG;
 377
 378         if (orinoco_lock(priv, &flags) != 0)
 379                 return -EBUSY;
 380
 381         /* NULL the string (for NULL termination & ESSID = ANY) - Jean II */
 382         memset(priv->desired_essid, 0, sizeof(priv->desired_essid));
 383
 384         /* If not ANY, get the new ESSID */
 385         if (erq->flags)
 386                 memcpy(priv->desired_essid, essidbuf, erq->length);
 387
 388         orinoco_unlock(priv, &flags);
 389
 390         return -EINPROGRESS;            /* Call commit handler */
 391 }
 392
 393 static int orinoco_ioctl_getessid(struct net_device *dev,
 394                                   struct iw_request_info *info,
 395                                   struct iw_point *erq,
 396                                   char *essidbuf)
 397 {
 398         struct orinoco_private *priv = ndev_priv(dev);
 399         int active;
 400         int err = 0;
 401         unsigned long flags;
 402
 403         if (netif_running(dev)) {
 404                 err = orinoco_hw_get_essid(priv, &active, essidbuf);
 405                 if (err < 0)
 406                         return err;
 407                 erq->length = err;
 408         } else {
 409                 if (orinoco_lock(priv, &flags) != 0)
 410                         return -EBUSY;
 411                 memcpy(essidbuf, priv->desired_essid, IW_ESSID_MAX_SIZE);
 412                 erq->length = strlen(priv->desired_essid);
 413                 orinoco_unlock(priv, &flags);
 414         }
 415
 416         erq->flags = 1;
 417
 418         return 0;
 419 }
 420
 421 static int orinoco_ioctl_setfreq(struct net_device *dev,
 422                                  struct iw_request_info *info,
 423                                  struct iw_freq *frq,
 424                                  char *extra)
 425 {
 426         struct orinoco_private *priv = ndev_priv(dev);
 427         int chan = -1;
 428         unsigned long flags;
 429         int err = -EINPROGRESS;         /* Call commit handler */
 430
 431         /* In infrastructure mode the AP sets the channel */
 432         if (priv->iw_mode == NL80211_IFTYPE_STATION)
 433                 return -EBUSY;
 434
 435         if ((frq->e == 0) && (frq->m <= 1000)) {
 436                 /* Setting by channel number */
 437                 chan = frq->m;
 438         } else {
 439                 /* Setting by frequency */
 440                 int denom = 1;
 441                 int i;
 442
 443                 /* Calculate denominator to rescale to MHz */
 444                 for (i = 0; i < (6 - frq->e); i++)
 445                         denom *= 10;
 446
 447                 chan = ieee80211_freq_to_dsss_chan(frq->m / denom);
 448         }
 449
 450         if ((chan < 1) || (chan > NUM_CHANNELS) ||
 451              !(priv->channel_mask & (1 << (chan-1))))
 452                 return -EINVAL;
 453
 454         if (orinoco_lock(priv, &flags) != 0)
 455                 return -EBUSY;
 456
 457         priv->channel = chan;
 458         if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
 459                 /* Fast channel change - no commit if successful */
 460                 hermes_t *hw = &priv->hw;
 461                 err = hermes_docmd_wait(hw, HERMES_CMD_TEST |
 462                                             HERMES_TEST_SET_CHANNEL,
 463                                         chan, NULL);
 464         }
 465         orinoco_unlock(priv, &flags);
 466
 467         return err;
 468 }
 469
 470 static int orinoco_ioctl_getfreq(struct net_device *dev,
 471                                  struct iw_request_info *info,
 472                                  struct iw_freq *frq,
 473                                  char *extra)
 474 {
 475         struct orinoco_private *priv = ndev_priv(dev);
 476         int tmp;
 477
 478         /* Locking done in there */
 479         tmp = orinoco_hw_get_freq(priv);
 480         if (tmp < 0)
 481                 return tmp;
 482
 483         frq->m = tmp * 100000;
 484         frq->e = 1;
 485
 486         return 0;
 487 }
 488
 489 static int orinoco_ioctl_getsens(struct net_device *dev,
 490                                  struct iw_request_info *info,
 491                                  struct iw_param *srq,
 492                                  char *extra)
 493 {
 494         struct orinoco_private *priv = ndev_priv(dev);
 495         hermes_t *hw = &priv->hw;
 496         u16 val;
 497         int err;
 498         unsigned long flags;
 499
 500         if (!priv->has_sensitivity)
 501                 return -EOPNOTSUPP;
 502
 503         if (orinoco_lock(priv, &flags) != 0)
 504                 return -EBUSY;
 505         err = hermes_read_wordrec(hw, USER_BAP,
 506                                   HERMES_RID_CNFSYSTEMSCALE, &val);
 507         orinoco_unlock(priv, &flags);
 508
 509         if (err)
 510                 return err;
 511
 512         srq->value = val;
 513         srq->fixed = 0; /* auto */
 514
 515         return 0;
 516 }
 517
 518 static int orinoco_ioctl_setsens(struct net_device *dev,
 519                                  struct iw_request_info *info,
 520                                  struct iw_param *srq,
 521                                  char *extra)
 522 {
 523         struct orinoco_private *priv = ndev_priv(dev);
 524         int val = srq->value;
 525         unsigned long flags;
 526
 527         if (!priv->has_sensitivity)
 528                 return -EOPNOTSUPP;
 529
 530         if ((val < 1) || (val > 3))
 531                 return -EINVAL;
 532
 533         if (orinoco_lock(priv, &flags) != 0)
 534                 return -EBUSY;
 535         priv->ap_density = val;
 536         orinoco_unlock(priv, &flags);
 537
 538         return -EINPROGRESS;            /* Call commit handler */
 539 }
 540
 541 static int orinoco_ioctl_setrts(struct net_device *dev,
 542                                 struct iw_request_info *info,
 543                                 struct iw_param *rrq,
 544                                 char *extra)
 545 {
 546         struct orinoco_private *priv = ndev_priv(dev);
 547         int val = rrq->value;
 548         unsigned long flags;
 549
 550         if (rrq->disabled)
 551                 val = 2347;
 552
 553         if ((val < 0) || (val > 2347))
 554                 return -EINVAL;
 555
 556         if (orinoco_lock(priv, &flags) != 0)
 557                 return -EBUSY;
 558
 559         priv->rts_thresh = val;
 560         orinoco_unlock(priv, &flags);
 561
 562         return -EINPROGRESS;            /* Call commit handler */
 563 }
 564
 565 static int orinoco_ioctl_getrts(struct net_device *dev,
 566                                 struct iw_request_info *info,
 567                                 struct iw_param *rrq,
 568                                 char *extra)
 569 {
 570         struct orinoco_private *priv = ndev_priv(dev);
 571
 572         rrq->value = priv->rts_thresh;
 573         rrq->disabled = (rrq->value == 2347);
 574         rrq->fixed = 1;
 575
 576         return 0;
 577 }
 578
 579 static int orinoco_ioctl_setfrag(struct net_device *dev,
 580                                  struct iw_request_info *info,
 581                                  struct iw_param *frq,
 582                                  char *extra)
 583 {
 584         struct orinoco_private *priv = ndev_priv(dev);
 585         int err = -EINPROGRESS;         /* Call commit handler */
 586         unsigned long flags;
 587
 588         if (orinoco_lock(priv, &flags) != 0)
 589                 return -EBUSY;
 590
 591         if (priv->has_mwo) {
 592                 if (frq->disabled)
 593                         priv->mwo_robust = 0;
 594                 else {
 595                         if (frq->fixed)
 596                                 printk(KERN_WARNING "%s: Fixed fragmentation "
 597                                        "is not supported on this firmware. "
 598                                        "Using MWO robust instead.\n",
 599                                        dev->name);
 600                         priv->mwo_robust = 1;
 601                 }
 602         } else {
 603                 if (frq->disabled)
 604                         priv->frag_thresh = 2346;
 605                 else {
 606                         if ((frq->value < 256) || (frq->value > 2346))
 607                                 err = -EINVAL;
 608                         else
 609                                 /* must be even */
 610                                 priv->frag_thresh = frq->value & ~0x1;
 611                 }
 612         }
 613
 614         orinoco_unlock(priv, &flags);
 615
 616         return err;
 617 }
 618
 619 static int orinoco_ioctl_getfrag(struct net_device *dev,
 620                                  struct iw_request_info *info,
 621                                  struct iw_param *frq,
 622                                  char *extra)
 623 {
 624         struct orinoco_private *priv = ndev_priv(dev);
 625         hermes_t *hw = &priv->hw;
 626         int err;
 627         u16 val;
 628         unsigned long flags;
 629
 630         if (orinoco_lock(priv, &flags) != 0)
 631                 return -EBUSY;
 632
 633         if (priv->has_mwo) {
 634                 err = hermes_read_wordrec(hw, USER_BAP,
 635                                           HERMES_RID_CNFMWOROBUST_AGERE,
 636                                           &val);
 637                 if (err)
 638                         val = 0;
 639
 640                 frq->value = val ? 2347 : 0;
 641                 frq->disabled = !val;
 642                 frq->fixed = 0;
 643         } else {
 644                 err = hermes_read_wordrec(hw, USER_BAP,
 645                                           HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
 646                                           &val);
 647                 if (err)
 648                         val = 0;
 649
 650                 frq->value = val;
 651                 frq->disabled = (val >= 2346);
 652                 frq->fixed = 1;
 653         }
 654
 655         orinoco_unlock(priv, &flags);
 656
 657         return err;
 658 }
 659
 660 static int orinoco_ioctl_setrate(struct net_device *dev,
 661                                  struct iw_request_info *info,
 662                                  struct iw_param *rrq,
 663                                  char *extra)
 664 {
 665         struct orinoco_private *priv = ndev_priv(dev);
 666         int ratemode;
 667         int bitrate; /* 100s of kilobits */
 668         unsigned long flags;
 669
 670         /* As the user space doesn't know our highest rate, it uses -1
 671          * to ask us to set the highest rate.  Test it using "iwconfig
 672          * ethX rate auto" - Jean II */
 673         if (rrq->value == -1)
 674                 bitrate = 110;
 675         else {
 676                 if (rrq->value % 100000)
 677                         return -EINVAL;
 678                 bitrate = rrq->value / 100000;
 679         }
 680
 681         ratemode = orinoco_get_bitratemode(bitrate, !rrq->fixed);
 682
 683         if (ratemode == -1)
 684                 return -EINVAL;
 685
 686         if (orinoco_lock(priv, &flags) != 0)
 687                 return -EBUSY;
 688         priv->bitratemode = ratemode;
 689         orinoco_unlock(priv, &flags);
 690
 691         return -EINPROGRESS;
 692 }
 693
 694 static int orinoco_ioctl_getrate(struct net_device *dev,
 695                                  struct iw_request_info *info,
 696                                  struct iw_param *rrq,
 697                                  char *extra)
 698 {
 699         struct orinoco_private *priv = ndev_priv(dev);
 700         int err = 0;
 701         int bitrate, automatic;
 702         unsigned long flags;
 703
 704         if (orinoco_lock(priv, &flags) != 0)
 705                 return -EBUSY;
 706
 707         orinoco_get_ratemode_cfg(priv->bitratemode, &bitrate, &automatic);
 708
 709         /* If the interface is running we try to find more about the
 710            current mode */
 711         if (netif_running(dev))
 712                 err = orinoco_hw_get_act_bitrate(priv, &bitrate);
 713
 714         orinoco_unlock(priv, &flags);
 715
 716         rrq->value = bitrate;
 717         rrq->fixed = !automatic;
 718         rrq->disabled = 0;
 719
 720         return err;
 721 }
 722
 723 static int orinoco_ioctl_setpower(struct net_device *dev,
 724                                   struct iw_request_info *info,
 725                                   struct iw_param *prq,
 726                                   char *extra)
 727 {
 728         struct orinoco_private *priv = ndev_priv(dev);
 729         int err = -EINPROGRESS;         /* Call commit handler */
 730         unsigned long flags;
 731
 732         if (orinoco_lock(priv, &flags) != 0)
 733                 return -EBUSY;
 734
 735         if (prq->disabled) {
 736                 priv->pm_on = 0;
 737         } else {
 738                 switch (prq->flags & IW_POWER_MODE) {
 739                 case IW_POWER_UNICAST_R:
 740                         priv->pm_mcast = 0;
 741                         priv->pm_on = 1;
 742                         break;
 743                 case IW_POWER_ALL_R:
 744                         priv->pm_mcast = 1;
 745                         priv->pm_on = 1;
 746                         break;
 747                 case IW_POWER_ON:
 748                         /* No flags : but we may have a value - Jean II */
 749                         break;
 750                 default:
 751                         err = -EINVAL;
 752                         goto out;
 753                 }
 754
 755                 if (prq->flags & IW_POWER_TIMEOUT) {
 756                         priv->pm_on = 1;
 757                         priv->pm_timeout = prq->value / 1000;
 758                 }
 759                 if (prq->flags & IW_POWER_PERIOD) {
 760                         priv->pm_on = 1;
 761                         priv->pm_period = prq->value / 1000;
 762                 }
 763                 /* It's valid to not have a value if we are just toggling
 764                  * the flags... Jean II */
 765                 if (!priv->pm_on) {
 766                         err = -EINVAL;
 767                         goto out;
 768                 }
 769         }
 770
 771  out:
 772         orinoco_unlock(priv, &flags);
 773
 774         return err;
 775 }
 776
 777 static int orinoco_ioctl_getpower(struct net_device *dev,
 778                                   struct iw_request_info *info,
 779                                   struct iw_param *prq,
 780                                   char *extra)
 781 {
 782         struct orinoco_private *priv = ndev_priv(dev);
 783         hermes_t *hw = &priv->hw;
 784         int err = 0;
 785         u16 enable, period, timeout, mcast;
 786         unsigned long flags;
 787
 788         if (orinoco_lock(priv, &flags) != 0)
 789                 return -EBUSY;
 790
 791         err = hermes_read_wordrec(hw, USER_BAP,
 792                                   HERMES_RID_CNFPMENABLED, &enable);
 793         if (err)
 794                 goto out;
 795
 796         err = hermes_read_wordrec(hw, USER_BAP,
 797                                   HERMES_RID_CNFMAXSLEEPDURATION, &period);
 798         if (err)
 799                 goto out;
 800
 801         err = hermes_read_wordrec(hw, USER_BAP,
 802                                   HERMES_RID_CNFPMHOLDOVERDURATION, &timeout);
 803         if (err)
 804                 goto out;
 805
 806         err = hermes_read_wordrec(hw, USER_BAP,
 807                                   HERMES_RID_CNFMULTICASTRECEIVE, &mcast);
 808         if (err)
 809                 goto out;
 810
 811         prq->disabled = !enable;
 812         /* Note : by default, display the period */
 813         if ((prq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
 814                 prq->flags = IW_POWER_TIMEOUT;
 815                 prq->value = timeout * 1000;
 816         } else {
 817                 prq->flags = IW_POWER_PERIOD;
 818                 prq->value = period * 1000;
 819         }
 820         if (mcast)
 821                 prq->flags |= IW_POWER_ALL_R;
 822         else
 823                 prq->flags |= IW_POWER_UNICAST_R;
 824
 825  out:
 826         orinoco_unlock(priv, &flags);
 827
 828         return err;
 829 }
 830
 831 static int orinoco_ioctl_set_encodeext(struct net_device *dev,
 832                                        struct iw_request_info *info,
 833                                        union iwreq_data *wrqu,
 834                                        char *extra)
 835 {
 836         struct orinoco_private *priv = ndev_priv(dev);
 837         struct iw_point *encoding = &wrqu->encoding;
 838         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
 839         int idx, alg = ext->alg, set_key = 1;
 840         unsigned long flags;
 841         int err = -EINVAL;
 842
 843         if (orinoco_lock(priv, &flags) != 0)
 844                 return -EBUSY;
 845
 846         /* Determine and validate the key index */
 847         idx = encoding->flags & IW_ENCODE_INDEX;
 848         if (idx) {
 849                 if ((idx < 1) || (idx > 4))
 850                         goto out;
 851                 idx--;
 852         } else
 853                 idx = priv->tx_key;
 854
 855         if (encoding->flags & IW_ENCODE_DISABLED)
 856                 alg = IW_ENCODE_ALG_NONE;
 857
 858         if (priv->has_wpa && (alg != IW_ENCODE_ALG_TKIP)) {
 859                 /* Clear any TKIP TX key we had */
 860                 (void) orinoco_clear_tkip_key(priv, priv->tx_key);
 861         }
 862
 863         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
 864                 priv->tx_key = idx;
 865                 set_key = ((alg == IW_ENCODE_ALG_TKIP) ||
 866                            (ext->key_len > 0)) ? 1 : 0;
 867         }
 868
 869         if (set_key) {
 870                 /* Set the requested key first */
 871                 switch (alg) {
 872                 case IW_ENCODE_ALG_NONE:
 873                         priv->encode_alg = ORINOCO_ALG_NONE;
 874                         err = orinoco_set_key(priv, idx, ORINOCO_ALG_NONE,
 875                                               NULL, 0, NULL, 0);
 876                         break;
 877
 878                 case IW_ENCODE_ALG_WEP:
 879                         if (ext->key_len <= 0)
 880                                 goto out;
 881
 882                         priv->encode_alg = ORINOCO_ALG_WEP;
 883                         err = orinoco_set_key(priv, idx, ORINOCO_ALG_WEP,
 884                                               ext->key, ext->key_len, NULL, 0);
 885                         break;
 886
 887                 case IW_ENCODE_ALG_TKIP:
 888                 {
 889                         u8 *tkip_iv = NULL;
 890
 891                         if (!priv->has_wpa ||
 892                             (ext->key_len > sizeof(struct orinoco_tkip_key)))
 893                                 goto out;
 894
 895                         priv->encode_alg = ORINOCO_ALG_TKIP;
 896
 897                         if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
 898                                 tkip_iv = &ext->rx_seq[0];
 899
 900                         err = orinoco_set_key(priv, idx, ORINOCO_ALG_TKIP,
 901                                               ext->key, ext->key_len, tkip_iv,
 902                                               ORINOCO_SEQ_LEN);
 903
 904                         err = __orinoco_hw_set_tkip_key(priv, idx,
 905                                  ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY,
 906                                  priv->keys[idx].key,
 907                                  tkip_iv, ORINOCO_SEQ_LEN, NULL, 0);
 908                         if (err)
 909                                 printk(KERN_ERR "%s: Error %d setting TKIP key"
 910                                        "\n", dev->name, err);
 911
 912                         goto out;
 913                 }
 914                 default:
 915                         goto out;
 916                 }
 917         }
 918         err = -EINPROGRESS;
 919  out:
 920         orinoco_unlock(priv, &flags);
 921
 922         return err;
 923 }
 924
 925 static int orinoco_ioctl_get_encodeext(struct net_device *dev,
 926                                        struct iw_request_info *info,
 927                                        union iwreq_data *wrqu,
 928                                        char *extra)
 929 {
 930         struct orinoco_private *priv = ndev_priv(dev);
 931         struct iw_point *encoding = &wrqu->encoding;
 932         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
 933         int idx, max_key_len;
 934         unsigned long flags;
 935         int err;
 936
 937         if (orinoco_lock(priv, &flags) != 0)
 938                 return -EBUSY;
 939
 940         err = -EINVAL;
 941         max_key_len = encoding->length - sizeof(*ext);
 942         if (max_key_len < 0)
 943                 goto out;
 944
 945         idx = encoding->flags & IW_ENCODE_INDEX;
 946         if (idx) {
 947                 if ((idx < 1) || (idx > 4))
 948                         goto out;
 949                 idx--;
 950         } else
 951                 idx = priv->tx_key;
 952
 953         encoding->flags = idx + 1;
 954         memset(ext, 0, sizeof(*ext));
 955
 956         switch (priv->encode_alg) {
 957         case ORINOCO_ALG_NONE:
 958                 ext->alg = IW_ENCODE_ALG_NONE;
 959                 ext->key_len = 0;
 960                 encoding->flags |= IW_ENCODE_DISABLED;
 961                 break;
 962         case ORINOCO_ALG_WEP:
 963                 ext->alg = IW_ENCODE_ALG_WEP;
 964                 ext->key_len = min(priv->keys[idx].key_len, max_key_len);
 965                 memcpy(ext->key, priv->keys[idx].key, ext->key_len);
 966                 encoding->flags |= IW_ENCODE_ENABLED;
 967                 break;
 968         case ORINOCO_ALG_TKIP:
 969                 ext->alg = IW_ENCODE_ALG_TKIP;
 970                 ext->key_len = min(priv->keys[idx].key_len, max_key_len);
 971                 memcpy(ext->key, priv->keys[idx].key, ext->key_len);
 972                 encoding->flags |= IW_ENCODE_ENABLED;
 973                 break;
 974         }
 975
 976         err = 0;
 977  out:
 978         orinoco_unlock(priv, &flags);
 979
 980         return err;
 981 }
 982
 983 static int orinoco_ioctl_set_auth(struct net_device *dev,
 984                                   struct iw_request_info *info,
 985                                   union iwreq_data *wrqu, char *extra)
 986 {
 987         struct orinoco_private *priv = ndev_priv(dev);
 988         hermes_t *hw = &priv->hw;
 989         struct iw_param *param = &wrqu->param;
 990         unsigned long flags;
 991         int ret = -EINPROGRESS;
 992
 993         if (orinoco_lock(priv, &flags) != 0)
 994                 return -EBUSY;
 995
 996         switch (param->flags & IW_AUTH_INDEX) {
 997         case IW_AUTH_WPA_VERSION:
 998         case IW_AUTH_CIPHER_PAIRWISE:
 999         case IW_AUTH_CIPHER_GROUP:
1000         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1001         case IW_AUTH_PRIVACY_INVOKED:
1002         case IW_AUTH_DROP_UNENCRYPTED:
1003                 /*
1004                  * orinoco does not use these parameters
1005                  */
1006                 break;
1007
1008         case IW_AUTH_KEY_MGMT:
1009                 /* wl_lkm implies value 2 == PSK for Hermes I
1010                  * which ties in with WEXT
1011                  * no other hints tho :(
1012                  */
1013                 priv->key_mgmt = param->value;
1014                 break;
1015
1016         case IW_AUTH_TKIP_COUNTERMEASURES:
1017                 /* When countermeasures are enabled, shut down the
1018                  * card; when disabled, re-enable the card. This must
1019                  * take effect immediately.
1020                  *
1021                  * TODO: Make sure that the EAPOL message is getting
1022                  *       out before card disabled
1023                  */
1024                 if (param->value) {
1025                         priv->tkip_cm_active = 1;
1026                         ret = hermes_enable_port(hw, 0);
1027                 } else {
1028                         priv->tkip_cm_active = 0;
1029                         ret = hermes_disable_port(hw, 0);
1030                 }
1031                 break;
1032
1033         case IW_AUTH_80211_AUTH_ALG:
1034                 if (param->value & IW_AUTH_ALG_SHARED_KEY)
1035                         priv->wep_restrict = 1;
1036                 else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM)
1037                         priv->wep_restrict = 0;
1038                 else
1039                         ret = -EINVAL;
1040                 break;
1041
1042         case IW_AUTH_WPA_ENABLED:
1043                 if (priv->has_wpa) {
1044                         priv->wpa_enabled = param->value ? 1 : 0;
1045                 } else {
1046                         if (param->value)
1047                                 ret = -EOPNOTSUPP;
1048                         /* else silently accept disable of WPA */
1049                         priv->wpa_enabled = 0;
1050                 }
1051                 break;
1052
1053         default:
1054                 ret = -EOPNOTSUPP;
1055         }
1056
1057         orinoco_unlock(priv, &flags);
1058         return ret;
1059 }
1060
1061 static int orinoco_ioctl_get_auth(struct net_device *dev,
1062                                   struct iw_request_info *info,
1063                                   union iwreq_data *wrqu, char *extra)
1064 {
1065         struct orinoco_private *priv = ndev_priv(dev);
1066         struct iw_param *param = &wrqu->param;
1067         unsigned long flags;
1068         int ret = 0;
1069
1070         if (orinoco_lock(priv, &flags) != 0)
1071                 return -EBUSY;
1072
1073         switch (param->flags & IW_AUTH_INDEX) {
1074         case IW_AUTH_KEY_MGMT:
1075                 param->value = priv->key_mgmt;
1076                 break;
1077
1078         case IW_AUTH_TKIP_COUNTERMEASURES:
1079                 param->value = priv->tkip_cm_active;
1080                 break;
1081
1082         case IW_AUTH_80211_AUTH_ALG:
1083                 if (priv->wep_restrict)
1084                         param->value = IW_AUTH_ALG_SHARED_KEY;
1085                 else
1086                         param->value = IW_AUTH_ALG_OPEN_SYSTEM;
1087                 break;
1088
1089         case IW_AUTH_WPA_ENABLED:
1090                 param->value = priv->wpa_enabled;
1091                 break;
1092
1093         default:
1094                 ret = -EOPNOTSUPP;
1095         }
1096
1097         orinoco_unlock(priv, &flags);
1098         return ret;
1099 }
1100
1101 static int orinoco_ioctl_set_genie(struct net_device *dev,
1102                                    struct iw_request_info *info,
1103                                    union iwreq_data *wrqu, char *extra)
1104 {
1105         struct orinoco_private *priv = ndev_priv(dev);
1106         u8 *buf;
1107         unsigned long flags;
1108
1109         /* cut off at IEEE80211_MAX_DATA_LEN */
1110         if ((wrqu->data.length > IEEE80211_MAX_DATA_LEN) ||
1111             (wrqu->data.length && (extra == NULL)))
1112                 return -EINVAL;
1113
1114         if (wrqu->data.length) {
1115                 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
1116                 if (buf == NULL)
1117                         return -ENOMEM;
1118
1119                 memcpy(buf, extra, wrqu->data.length);
1120         } else
1121                 buf = NULL;
1122
1123         if (orinoco_lock(priv, &flags) != 0) {
1124                 kfree(buf);
1125                 return -EBUSY;
1126         }
1127
1128         kfree(priv->wpa_ie);
1129         priv->wpa_ie = buf;
1130         priv->wpa_ie_len = wrqu->data.length;
1131
1132         if (priv->wpa_ie) {
1133                 /* Looks like wl_lkm wants to check the auth alg, and
1134                  * somehow pass it to the firmware.
1135                  * Instead it just calls the key mgmt rid
1136                  *   - we do this in set auth.
1137                  */
1138         }
1139
1140         orinoco_unlock(priv, &flags);
1141         return 0;
1142 }
1143
1144 static int orinoco_ioctl_get_genie(struct net_device *dev,
1145                                    struct iw_request_info *info,
1146                                    union iwreq_data *wrqu, char *extra)
1147 {
1148         struct orinoco_private *priv = ndev_priv(dev);
1149         unsigned long flags;
1150         int err = 0;
1151
1152         if (orinoco_lock(priv, &flags) != 0)
1153                 return -EBUSY;
1154
1155         if ((priv->wpa_ie_len == 0) || (priv->wpa_ie == NULL)) {
1156                 wrqu->data.length = 0;
1157                 goto out;
1158         }
1159
1160         if (wrqu->data.length < priv->wpa_ie_len) {
1161                 err = -E2BIG;
1162                 goto out;
1163         }
1164
1165         wrqu->data.length = priv->wpa_ie_len;
1166         memcpy(extra, priv->wpa_ie, priv->wpa_ie_len);
1167
1168 out:
1169         orinoco_unlock(priv, &flags);
1170         return err;
1171 }
1172
1173 static int orinoco_ioctl_set_mlme(struct net_device *dev,
1174                                   struct iw_request_info *info,
1175                                   union iwreq_data *wrqu, char *extra)
1176 {
1177         struct orinoco_private *priv = ndev_priv(dev);
1178         struct iw_mlme *mlme = (struct iw_mlme *)extra;
1179         unsigned long flags;
1180         int ret = 0;
1181
1182         if (orinoco_lock(priv, &flags) != 0)
1183                 return -EBUSY;
1184
1185         switch (mlme->cmd) {
1186         case IW_MLME_DEAUTH:
1187                 /* silently ignore */
1188                 break;
1189
1190         case IW_MLME_DISASSOC:
1191
1192                 ret = orinoco_hw_disassociate(priv, mlme->addr.sa_data,
1193                                               mlme->reason_code);
1194                 break;
1195
1196         default:
1197                 ret = -EOPNOTSUPP;
1198         }
1199
1200         orinoco_unlock(priv, &flags);
1201         return ret;
1202 }
1203
1204 static int orinoco_ioctl_getretry(struct net_device *dev,
1205                                   struct iw_request_info *info,
1206                                   struct iw_param *rrq,
1207                                   char *extra)
1208 {
1209         struct orinoco_private *priv = ndev_priv(dev);
1210         hermes_t *hw = &priv->hw;
1211         int err = 0;
1212         u16 short_limit, long_limit, lifetime;
1213         unsigned long flags;
1214
1215         if (orinoco_lock(priv, &flags) != 0)
1216                 return -EBUSY;
1217
1218         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_SHORTRETRYLIMIT,
1219                                   &short_limit);
1220         if (err)
1221                 goto out;
1222
1223         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_LONGRETRYLIMIT,
1224                                   &long_limit);
1225         if (err)
1226                 goto out;
1227
1228         err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_MAXTRANSMITLIFETIME,
1229                                   &lifetime);
1230         if (err)
1231                 goto out;
1232
1233         rrq->disabled = 0;              /* Can't be disabled */
1234
1235         /* Note : by default, display the retry number */
1236         if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
1237                 rrq->flags = IW_RETRY_LIFETIME;
1238                 rrq->value = lifetime * 1000;   /* ??? */
1239         } else {
1240                 /* By default, display the min number */
1241                 if ((rrq->flags & IW_RETRY_LONG)) {
1242                         rrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
1243                         rrq->value = long_limit;
1244                 } else {
1245                         rrq->flags = IW_RETRY_LIMIT;
1246                         rrq->value = short_limit;
1247                         if (short_limit != long_limit)
1248                                 rrq->flags |= IW_RETRY_SHORT;
1249                 }
1250         }
1251
1252  out:
1253         orinoco_unlock(priv, &flags);
1254
1255         return err;
1256 }
1257
1258 static int orinoco_ioctl_reset(struct net_device *dev,
1259                                struct iw_request_info *info,
1260                                void *wrqu,
1261                                char *extra)
1262 {
1263         struct orinoco_private *priv = ndev_priv(dev);
1264
1265         if (!capable(CAP_NET_ADMIN))
1266                 return -EPERM;
1267
1268         if (info->cmd == (SIOCIWFIRSTPRIV + 0x1)) {
1269                 printk(KERN_DEBUG "%s: Forcing reset!\n", dev->name);
1270
1271                 /* Firmware reset */
1272                 orinoco_reset(&priv->reset_work);
1273         } else {
1274                 printk(KERN_DEBUG "%s: Force scheduling reset!\n", dev->name);
1275
1276                 schedule_work(&priv->reset_work);
1277         }
1278
1279         return 0;
1280 }
1281
1282 static int orinoco_ioctl_setibssport(struct net_device *dev,
1283                                      struct iw_request_info *info,
1284                                      void *wrqu,
1285                                      char *extra)
1286
1287 {
1288         struct orinoco_private *priv = ndev_priv(dev);
1289         int val = *((int *) extra);
1290         unsigned long flags;
1291
1292         if (orinoco_lock(priv, &flags) != 0)
1293                 return -EBUSY;
1294
1295         priv->ibss_port = val;
1296
1297         /* Actually update the mode we are using */
1298         set_port_type(priv);
1299
1300         orinoco_unlock(priv, &flags);
1301         return -EINPROGRESS;            /* Call commit handler */
1302 }
1303
1304 static int orinoco_ioctl_getibssport(struct net_device *dev,
1305                                      struct iw_request_info *info,
1306                                      void *wrqu,
1307                                      char *extra)
1308 {
1309         struct orinoco_private *priv = ndev_priv(dev);
1310         int *val = (int *) extra;
1311
1312         *val = priv->ibss_port;
1313         return 0;
1314 }
1315
1316 static int orinoco_ioctl_setport3(struct net_device *dev,
1317                                   struct iw_request_info *info,
1318                                   void *wrqu,
1319                                   char *extra)
1320 {
1321         struct orinoco_private *priv = ndev_priv(dev);
1322         int val = *((int *) extra);
1323         int err = 0;
1324         unsigned long flags;
1325
1326         if (orinoco_lock(priv, &flags) != 0)
1327                 return -EBUSY;
1328
1329         switch (val) {
1330         case 0: /* Try to do IEEE ad-hoc mode */
1331                 if (!priv->has_ibss) {
1332                         err = -EINVAL;
1333                         break;
1334                 }
1335                 priv->prefer_port3 = 0;
1336
1337                 break;
1338
1339         case 1: /* Try to do Lucent proprietary ad-hoc mode */
1340                 if (!priv->has_port3) {
1341                         err = -EINVAL;
1342                         break;
1343                 }
1344                 priv->prefer_port3 = 1;
1345                 break;
1346
1347         default:
1348                 err = -EINVAL;
1349         }
1350
1351         if (!err) {
1352                 /* Actually update the mode we are using */
1353                 set_port_type(priv);
1354                 err = -EINPROGRESS;
1355         }
1356
1357         orinoco_unlock(priv, &flags);
1358
1359         return err;
1360 }
1361
1362 static int orinoco_ioctl_getport3(struct net_device *dev,
1363                                   struct iw_request_info *info,
1364                                   void *wrqu,
1365                                   char *extra)
1366 {
1367         struct orinoco_private *priv = ndev_priv(dev);
1368         int *val = (int *) extra;
1369
1370         *val = priv->prefer_port3;
1371         return 0;
1372 }
1373
1374 static int orinoco_ioctl_setpreamble(struct net_device *dev,
1375                                      struct iw_request_info *info,
1376                                      void *wrqu,
1377                                      char *extra)
1378 {
1379         struct orinoco_private *priv = ndev_priv(dev);
1380         unsigned long flags;
1381         int val;
1382
1383         if (!priv->has_preamble)
1384                 return -EOPNOTSUPP;
1385
1386         /* 802.11b has recently defined some short preamble.
1387          * Basically, the Phy header has been reduced in size.
1388          * This increase performance, especially at high rates
1389          * (the preamble is transmitted at 1Mb/s), unfortunately
1390          * this give compatibility troubles... - Jean II */
1391         val = *((int *) extra);
1392
1393         if (orinoco_lock(priv, &flags) != 0)
1394                 return -EBUSY;
1395
1396         if (val)
1397                 priv->preamble = 1;
1398         else
1399                 priv->preamble = 0;
1400
1401         orinoco_unlock(priv, &flags);
1402
1403         return -EINPROGRESS;            /* Call commit handler */
1404 }
1405
1406 static int orinoco_ioctl_getpreamble(struct net_device *dev,
1407                                      struct iw_request_info *info,
1408                                      void *wrqu,
1409                                      char *extra)
1410 {
1411         struct orinoco_private *priv = ndev_priv(dev);
1412         int *val = (int *) extra;
1413
1414         if (!priv->has_preamble)
1415                 return -EOPNOTSUPP;
1416
1417         *val = priv->preamble;
1418         return 0;
1419 }
1420
1421 /* ioctl interface to hermes_read_ltv()
1422  * To use with iwpriv, pass the RID as the token argument, e.g.
1423  * iwpriv get_rid [0xfc00]
1424  * At least Wireless Tools 25 is required to use iwpriv.
1425  * For Wireless Tools 25 and 26 append "dummy" are the end. */
1426 static int orinoco_ioctl_getrid(struct net_device *dev,
1427                                 struct iw_request_info *info,
1428                                 struct iw_point *data,
1429                                 char *extra)
1430 {
1431         struct orinoco_private *priv = ndev_priv(dev);
1432         hermes_t *hw = &priv->hw;
1433         int rid = data->flags;
1434         u16 length;
1435         int err;
1436         unsigned long flags;
1437
1438         /* It's a "get" function, but we don't want users to access the
1439          * WEP key and other raw firmware data */
1440         if (!capable(CAP_NET_ADMIN))
1441                 return -EPERM;
1442
1443         if (rid < 0xfc00 || rid > 0xffff)
1444                 return -EINVAL;
1445
1446         if (orinoco_lock(priv, &flags) != 0)
1447                 return -EBUSY;
1448
1449         err = hermes_read_ltv(hw, USER_BAP, rid, MAX_RID_LEN, &length,
1450                               extra);
1451         if (err)
1452                 goto out;
1453
1454         data->length = min_t(u16, HERMES_RECLEN_TO_BYTES(length),
1455                              MAX_RID_LEN);
1456
1457  out:
1458         orinoco_unlock(priv, &flags);
1459         return err;
1460 }
1461
1462
1463 /* Commit handler, called after set operations */
1464 static int orinoco_ioctl_commit(struct net_device *dev,
1465                                 struct iw_request_info *info,
1466                                 void *wrqu,
1467                                 char *extra)
1468 {
1469         struct orinoco_private *priv = ndev_priv(dev);
1470         unsigned long flags;
1471         int err = 0;
1472
1473         if (!priv->open)
1474                 return 0;
1475
1476         if (orinoco_lock(priv, &flags) != 0)
1477                 return err;
1478
1479         err = orinoco_commit(priv);
1480
1481         orinoco_unlock(priv, &flags);
1482         return err;
1483 }
1484
1485 static const struct iw_priv_args orinoco_privtab[] = {
1486         { SIOCIWFIRSTPRIV + 0x0, 0, 0, "force_reset" },
1487         { SIOCIWFIRSTPRIV + 0x1, 0, 0, "card_reset" },
1488         { SIOCIWFIRSTPRIV + 0x2, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1489           0, "set_port3" },
1490         { SIOCIWFIRSTPRIV + 0x3, 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1491           "get_port3" },
1492         { SIOCIWFIRSTPRIV + 0x4, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1493           0, "set_preamble" },
1494         { SIOCIWFIRSTPRIV + 0x5, 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1495           "get_preamble" },
1496         { SIOCIWFIRSTPRIV + 0x6, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1497           0, "set_ibssport" },
1498         { SIOCIWFIRSTPRIV + 0x7, 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1499           "get_ibssport" },
1500         { SIOCIWFIRSTPRIV + 0x9, 0, IW_PRIV_TYPE_BYTE | MAX_RID_LEN,
1501           "get_rid" },
1502 };
1503
1504
1505 /*
1506  * Structures to export the Wireless Handlers
1507  */
1508
1509 #define STD_IW_HANDLER(id, func) \
1510         [IW_IOCTL_IDX(id)] = (iw_handler) func
1511 static const iw_handler orinoco_handler[] = {
1512         STD_IW_HANDLER(SIOCSIWCOMMIT,   orinoco_ioctl_commit),
1513         STD_IW_HANDLER(SIOCGIWNAME,     cfg80211_wext_giwname),
1514         STD_IW_HANDLER(SIOCSIWFREQ,     orinoco_ioctl_setfreq),
1515         STD_IW_HANDLER(SIOCGIWFREQ,     orinoco_ioctl_getfreq),
1516         STD_IW_HANDLER(SIOCSIWMODE,     cfg80211_wext_siwmode),
1517         STD_IW_HANDLER(SIOCGIWMODE,     cfg80211_wext_giwmode),
1518         STD_IW_HANDLER(SIOCSIWSENS,     orinoco_ioctl_setsens),
1519         STD_IW_HANDLER(SIOCGIWSENS,     orinoco_ioctl_getsens),
1520         STD_IW_HANDLER(SIOCGIWRANGE,    cfg80211_wext_giwrange),
1521         STD_IW_HANDLER(SIOCSIWSPY,      iw_handler_set_spy),
1522         STD_IW_HANDLER(SIOCGIWSPY,      iw_handler_get_spy),
1523         STD_IW_HANDLER(SIOCSIWTHRSPY,   iw_handler_set_thrspy),
1524         STD_IW_HANDLER(SIOCGIWTHRSPY,   iw_handler_get_thrspy),
1525         STD_IW_HANDLER(SIOCSIWAP,       orinoco_ioctl_setwap),
1526         STD_IW_HANDLER(SIOCGIWAP,       orinoco_ioctl_getwap),
1527         STD_IW_HANDLER(SIOCSIWSCAN,     cfg80211_wext_siwscan),
1528         STD_IW_HANDLER(SIOCGIWSCAN,     cfg80211_wext_giwscan),
1529         STD_IW_HANDLER(SIOCSIWESSID,    orinoco_ioctl_setessid),
1530         STD_IW_HANDLER(SIOCGIWESSID,    orinoco_ioctl_getessid),
1531         STD_IW_HANDLER(SIOCSIWRATE,     orinoco_ioctl_setrate),
1532         STD_IW_HANDLER(SIOCGIWRATE,     orinoco_ioctl_getrate),
1533         STD_IW_HANDLER(SIOCSIWRTS,      orinoco_ioctl_setrts),
1534         STD_IW_HANDLER(SIOCGIWRTS,      orinoco_ioctl_getrts),
1535         STD_IW_HANDLER(SIOCSIWFRAG,     orinoco_ioctl_setfrag),
1536         STD_IW_HANDLER(SIOCGIWFRAG,     orinoco_ioctl_getfrag),
1537         STD_IW_HANDLER(SIOCGIWRETRY,    orinoco_ioctl_getretry),
1538         STD_IW_HANDLER(SIOCSIWENCODE,   orinoco_ioctl_setiwencode),
1539         STD_IW_HANDLER(SIOCGIWENCODE,   orinoco_ioctl_getiwencode),
1540         STD_IW_HANDLER(SIOCSIWPOWER,    orinoco_ioctl_setpower),
1541         STD_IW_HANDLER(SIOCGIWPOWER,    orinoco_ioctl_getpower),
1542         STD_IW_HANDLER(SIOCSIWGENIE,    orinoco_ioctl_set_genie),
1543         STD_IW_HANDLER(SIOCGIWGENIE,    orinoco_ioctl_get_genie),
1544         STD_IW_HANDLER(SIOCSIWMLME,     orinoco_ioctl_set_mlme),
1545         STD_IW_HANDLER(SIOCSIWAUTH,     orinoco_ioctl_set_auth),
1546         STD_IW_HANDLER(SIOCGIWAUTH,     orinoco_ioctl_get_auth),
1547         STD_IW_HANDLER(SIOCSIWENCODEEXT, orinoco_ioctl_set_encodeext),
1548         STD_IW_HANDLER(SIOCGIWENCODEEXT, orinoco_ioctl_get_encodeext),
1549 };
1550
1551
1552 /*
1553   Added typecasting since we no longer use iwreq_data -- Moustafa
1554  */
1555 static const iw_handler orinoco_private_handler[] = {
1556         [0] = (iw_handler) orinoco_ioctl_reset,
1557         [1] = (iw_handler) orinoco_ioctl_reset,
1558         [2] = (iw_handler) orinoco_ioctl_setport3,
1559         [3] = (iw_handler) orinoco_ioctl_getport3,
1560         [4] = (iw_handler) orinoco_ioctl_setpreamble,
1561         [5] = (iw_handler) orinoco_ioctl_getpreamble,
1562         [6] = (iw_handler) orinoco_ioctl_setibssport,
1563         [7] = (iw_handler) orinoco_ioctl_getibssport,
1564         [9] = (iw_handler) orinoco_ioctl_getrid,
1565 };
1566
1567 const struct iw_handler_def orinoco_handler_def = {
1568         .num_standard = ARRAY_SIZE(orinoco_handler),
1569         .num_private = ARRAY_SIZE(orinoco_private_handler),
1570         .num_private_args = ARRAY_SIZE(orinoco_privtab),
1571         .standard = orinoco_handler,
1572         .private = orinoco_private_handler,
1573         .private_args = orinoco_privtab,
1574         .get_wireless_stats = orinoco_get_wireless_stats,
1575 };