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