1/* ioctl() (mostly Linux Wireless Extensions) routines for Host AP driver */ 2 3#include <linux/slab.h> 4#include <linux/types.h> 5#include <linux/sched.h> 6#include <linux/ethtool.h> 7#include <linux/if_arp.h> 8#include <net/lib80211.h> 9 10#include "hostap_wlan.h" 11#include "hostap.h" 12#include "hostap_ap.h" 13 14static struct iw_statistics *hostap_get_wireless_stats(struct net_device *dev) 15{ 16 struct hostap_interface *iface; 17 local_info_t *local; 18 struct iw_statistics *wstats; 19 20 iface = netdev_priv(dev); 21 local = iface->local; 22 23 /* Why are we doing that ? Jean II */ 24 if (iface->type != HOSTAP_INTERFACE_MAIN) 25 return NULL; 26 27 wstats = &local->wstats; 28 29 wstats->status = 0; 30 wstats->discard.code = 31 local->comm_tallies.rx_discards_wep_undecryptable; 32 wstats->discard.misc = 33 local->comm_tallies.rx_fcs_errors + 34 local->comm_tallies.rx_discards_no_buffer + 35 local->comm_tallies.tx_discards_wrong_sa; 36 37 wstats->discard.retries = 38 local->comm_tallies.tx_retry_limit_exceeded; 39 wstats->discard.fragment = 40 local->comm_tallies.rx_message_in_bad_msg_fragments; 41 42 if (local->iw_mode != IW_MODE_MASTER && 43 local->iw_mode != IW_MODE_REPEAT) { 44 int update = 1; 45#ifdef in_atomic 46 /* RID reading might sleep and it must not be called in 47 * interrupt context or while atomic. However, this 48 * function seems to be called while atomic (at least in Linux 49 * 2.5.59). Update signal quality values only if in suitable 50 * context. Otherwise, previous values read from tick timer 51 * will be used. */ 52 if (in_atomic()) 53 update = 0; 54#endif /* in_atomic */ 55 56 if (update && prism2_update_comms_qual(dev) == 0) 57 wstats->qual.updated = IW_QUAL_ALL_UPDATED | 58 IW_QUAL_DBM; 59 60 wstats->qual.qual = local->comms_qual; 61 wstats->qual.level = local->avg_signal; 62 wstats->qual.noise = local->avg_noise; 63 } else { 64 wstats->qual.qual = 0; 65 wstats->qual.level = 0; 66 wstats->qual.noise = 0; 67 wstats->qual.updated = IW_QUAL_ALL_INVALID; 68 } 69 70 return wstats; 71} 72 73 74static int prism2_get_datarates(struct net_device *dev, u8 *rates) 75{ 76 struct hostap_interface *iface; 77 local_info_t *local; 78 u8 buf[12]; 79 int len; 80 u16 val; 81 82 iface = netdev_priv(dev); 83 local = iface->local; 84 85 len = local->func->get_rid(dev, HFA384X_RID_SUPPORTEDDATARATES, buf, 86 sizeof(buf), 0); 87 if (len < 2) 88 return 0; 89 90 val = le16_to_cpu(*(__le16 *) buf); /* string length */ 91 92 if (len - 2 < val || val > 10) 93 return 0; 94 95 memcpy(rates, buf + 2, val); 96 return val; 97} 98 99 100static int prism2_get_name(struct net_device *dev, 101 struct iw_request_info *info, 102 char *name, char *extra) 103{ 104 u8 rates[10]; 105 int len, i, over2 = 0; 106 107 len = prism2_get_datarates(dev, rates); 108 109 for (i = 0; i < len; i++) { 110 if (rates[i] == 0x0b || rates[i] == 0x16) { 111 over2 = 1; 112 break; 113 } 114 } 115 116 strcpy(name, over2 ? "IEEE 802.11b" : "IEEE 802.11-DS"); 117 118 return 0; 119} 120 121 122static int prism2_ioctl_siwencode(struct net_device *dev, 123 struct iw_request_info *info, 124 struct iw_point *erq, char *keybuf) 125{ 126 struct hostap_interface *iface; 127 local_info_t *local; 128 int i; 129 struct lib80211_crypt_data **crypt; 130 131 iface = netdev_priv(dev); 132 local = iface->local; 133 134 i = erq->flags & IW_ENCODE_INDEX; 135 if (i < 1 || i > 4) 136 i = local->crypt_info.tx_keyidx; 137 else 138 i--; 139 if (i < 0 || i >= WEP_KEYS) 140 return -EINVAL; 141 142 crypt = &local->crypt_info.crypt[i]; 143 144 if (erq->flags & IW_ENCODE_DISABLED) { 145 if (*crypt) 146 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt); 147 goto done; 148 } 149 150 if (*crypt != NULL && (*crypt)->ops != NULL && 151 strcmp((*crypt)->ops->name, "WEP") != 0) { 152 /* changing to use WEP; deinit previously used algorithm */ 153 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt); 154 } 155 156 if (*crypt == NULL) { 157 struct lib80211_crypt_data *new_crypt; 158 159 /* take WEP into use */ 160 new_crypt = kzalloc(sizeof(struct lib80211_crypt_data), 161 GFP_KERNEL); 162 if (new_crypt == NULL) 163 return -ENOMEM; 164 new_crypt->ops = lib80211_get_crypto_ops("WEP"); 165 if (!new_crypt->ops) { 166 request_module("lib80211_crypt_wep"); 167 new_crypt->ops = lib80211_get_crypto_ops("WEP"); 168 } 169 if (new_crypt->ops && try_module_get(new_crypt->ops->owner)) 170 new_crypt->priv = new_crypt->ops->init(i); 171 if (!new_crypt->ops || !new_crypt->priv) { 172 kfree(new_crypt); 173 new_crypt = NULL; 174 175 printk(KERN_WARNING "%s: could not initialize WEP: " 176 "load module hostap_crypt_wep.o\n", 177 dev->name); 178 return -EOPNOTSUPP; 179 } 180 *crypt = new_crypt; 181 } 182 183 if (erq->length > 0) { 184 int len = erq->length <= 5 ? 5 : 13; 185 int first = 1, j; 186 if (len > erq->length) 187 memset(keybuf + erq->length, 0, len - erq->length); 188 (*crypt)->ops->set_key(keybuf, len, NULL, (*crypt)->priv); 189 for (j = 0; j < WEP_KEYS; j++) { 190 if (j != i && local->crypt_info.crypt[j]) { 191 first = 0; 192 break; 193 } 194 } 195 if (first) 196 local->crypt_info.tx_keyidx = i; 197 } else { 198 /* No key data - just set the default TX key index */ 199 local->crypt_info.tx_keyidx = i; 200 } 201 202 done: 203 local->open_wep = erq->flags & IW_ENCODE_OPEN; 204 205 if (hostap_set_encryption(local)) { 206 printk(KERN_DEBUG "%s: set_encryption failed\n", dev->name); 207 return -EINVAL; 208 } 209 210 /* Do not reset port0 if card is in Managed mode since resetting will 211 * generate new IEEE 802.11 authentication which may end up in looping 212 * with IEEE 802.1X. Prism2 documentation seem to require port reset 213 * after WEP configuration. However, keys are apparently changed at 214 * least in Managed mode. */ 215 if (local->iw_mode != IW_MODE_INFRA && local->func->reset_port(dev)) { 216 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name); 217 return -EINVAL; 218 } 219 220 return 0; 221} 222 223 224static int prism2_ioctl_giwencode(struct net_device *dev, 225 struct iw_request_info *info, 226 struct iw_point *erq, char *key) 227{ 228 struct hostap_interface *iface; 229 local_info_t *local; 230 int i, len; 231 u16 val; 232 struct lib80211_crypt_data *crypt; 233 234 iface = netdev_priv(dev); 235 local = iface->local; 236 237 i = erq->flags & IW_ENCODE_INDEX; 238 if (i < 1 || i > 4) 239 i = local->crypt_info.tx_keyidx; 240 else 241 i--; 242 if (i < 0 || i >= WEP_KEYS) 243 return -EINVAL; 244 245 crypt = local->crypt_info.crypt[i]; 246 erq->flags = i + 1; 247 248 if (crypt == NULL || crypt->ops == NULL) { 249 erq->length = 0; 250 erq->flags |= IW_ENCODE_DISABLED; 251 return 0; 252 } 253 254 if (strcmp(crypt->ops->name, "WEP") != 0) { 255 /* only WEP is supported with wireless extensions, so just 256 * report that encryption is used */ 257 erq->length = 0; 258 erq->flags |= IW_ENCODE_ENABLED; 259 return 0; 260 } 261 262 /* Reads from HFA384X_RID_CNFDEFAULTKEY* return bogus values, so show 263 * the keys from driver buffer */ 264 len = crypt->ops->get_key(key, WEP_KEY_LEN, NULL, crypt->priv); 265 erq->length = (len >= 0 ? len : 0); 266 267 if (local->func->get_rid(dev, HFA384X_RID_CNFWEPFLAGS, &val, 2, 1) < 0) 268 { 269 printk("CNFWEPFLAGS reading failed\n"); 270 return -EOPNOTSUPP; 271 } 272 le16_to_cpus(&val); 273 if (val & HFA384X_WEPFLAGS_PRIVACYINVOKED) 274 erq->flags |= IW_ENCODE_ENABLED; 275 else 276 erq->flags |= IW_ENCODE_DISABLED; 277 if (val & HFA384X_WEPFLAGS_EXCLUDEUNENCRYPTED) 278 erq->flags |= IW_ENCODE_RESTRICTED; 279 else 280 erq->flags |= IW_ENCODE_OPEN; 281 282 return 0; 283} 284 285 286static int hostap_set_rate(struct net_device *dev) 287{ 288 struct hostap_interface *iface; 289 local_info_t *local; 290 int ret, basic_rates; 291 292 iface = netdev_priv(dev); 293 local = iface->local; 294 295 basic_rates = local->basic_rates & local->tx_rate_control; 296 if (!basic_rates || basic_rates != local->basic_rates) { 297 printk(KERN_INFO "%s: updating basic rate set automatically " 298 "to match with the new supported rate set\n", 299 dev->name); 300 if (!basic_rates) 301 basic_rates = local->tx_rate_control; 302 303 local->basic_rates = basic_rates; 304 if (hostap_set_word(dev, HFA384X_RID_CNFBASICRATES, 305 basic_rates)) 306 printk(KERN_WARNING "%s: failed to set " 307 "cnfBasicRates\n", dev->name); 308 } 309 310 ret = (hostap_set_word(dev, HFA384X_RID_TXRATECONTROL, 311 local->tx_rate_control) || 312 hostap_set_word(dev, HFA384X_RID_CNFSUPPORTEDRATES, 313 local->tx_rate_control) || 314 local->func->reset_port(dev)); 315 316 if (ret) { 317 printk(KERN_WARNING "%s: TXRateControl/cnfSupportedRates " 318 "setting to 0x%x failed\n", 319 dev->name, local->tx_rate_control); 320 } 321 322 /* Update TX rate configuration for all STAs based on new operational 323 * rate set. */ 324 hostap_update_rates(local); 325 326 return ret; 327} 328 329 330static int prism2_ioctl_siwrate(struct net_device *dev, 331 struct iw_request_info *info, 332 struct iw_param *rrq, char *extra) 333{ 334 struct hostap_interface *iface; 335 local_info_t *local; 336 337 iface = netdev_priv(dev); 338 local = iface->local; 339 340 if (rrq->fixed) { 341 switch (rrq->value) { 342 case 11000000: 343 local->tx_rate_control = HFA384X_RATES_11MBPS; 344 break; 345 case 5500000: 346 local->tx_rate_control = HFA384X_RATES_5MBPS; 347 break; 348 case 2000000: 349 local->tx_rate_control = HFA384X_RATES_2MBPS; 350 break; 351 case 1000000: 352 local->tx_rate_control = HFA384X_RATES_1MBPS; 353 break; 354 default: 355 local->tx_rate_control = HFA384X_RATES_1MBPS | 356 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS | 357 HFA384X_RATES_11MBPS; 358 break; 359 } 360 } else { 361 switch (rrq->value) { 362 case 11000000: 363 local->tx_rate_control = HFA384X_RATES_1MBPS | 364 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS | 365 HFA384X_RATES_11MBPS; 366 break; 367 case 5500000: 368 local->tx_rate_control = HFA384X_RATES_1MBPS | 369 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS; 370 break; 371 case 2000000: 372 local->tx_rate_control = HFA384X_RATES_1MBPS | 373 HFA384X_RATES_2MBPS; 374 break; 375 case 1000000: 376 local->tx_rate_control = HFA384X_RATES_1MBPS; 377 break; 378 default: 379 local->tx_rate_control = HFA384X_RATES_1MBPS | 380 HFA384X_RATES_2MBPS | HFA384X_RATES_5MBPS | 381 HFA384X_RATES_11MBPS; 382 break; 383 } 384 } 385 386 return hostap_set_rate(dev); 387} 388 389 390static int prism2_ioctl_giwrate(struct net_device *dev, 391 struct iw_request_info *info, 392 struct iw_param *rrq, char *extra) 393{ 394 u16 val; 395 struct hostap_interface *iface; 396 local_info_t *local; 397 int ret = 0; 398 399 iface = netdev_priv(dev); 400 local = iface->local; 401 402 if (local->func->get_rid(dev, HFA384X_RID_TXRATECONTROL, &val, 2, 1) < 403 0) 404 return -EINVAL; 405 406 if ((val & 0x1) && (val > 1)) 407 rrq->fixed = 0; 408 else 409 rrq->fixed = 1; 410 411 if (local->iw_mode == IW_MODE_MASTER && local->ap != NULL && 412 !local->fw_tx_rate_control) { 413 /* HFA384X_RID_CURRENTTXRATE seems to always be 2 Mbps in 414 * Host AP mode, so use the recorded TX rate of the last sent 415 * frame */ 416 rrq->value = local->ap->last_tx_rate > 0 ? 417 local->ap->last_tx_rate * 100000 : 11000000; 418 return 0; 419 } 420 421 if (local->func->get_rid(dev, HFA384X_RID_CURRENTTXRATE, &val, 2, 1) < 422 0) 423 return -EINVAL; 424 425 switch (val) { 426 case HFA384X_RATES_1MBPS: 427 rrq->value = 1000000; 428 break; 429 case HFA384X_RATES_2MBPS: 430 rrq->value = 2000000; 431 break; 432 case HFA384X_RATES_5MBPS: 433 rrq->value = 5500000; 434 break; 435 case HFA384X_RATES_11MBPS: 436 rrq->value = 11000000; 437 break; 438 default: 439 /* should not happen */ 440 rrq->value = 11000000; 441 ret = -EINVAL; 442 break; 443 } 444 445 return ret; 446} 447 448 449static int prism2_ioctl_siwsens(struct net_device *dev, 450 struct iw_request_info *info, 451 struct iw_param *sens, char *extra) 452{ 453 struct hostap_interface *iface; 454 local_info_t *local; 455 456 iface = netdev_priv(dev); 457 local = iface->local; 458 459 /* Set the desired AP density */ 460 if (sens->value < 1 || sens->value > 3) 461 return -EINVAL; 462 463 if (hostap_set_word(dev, HFA384X_RID_CNFSYSTEMSCALE, sens->value) || 464 local->func->reset_port(dev)) 465 return -EINVAL; 466 467 return 0; 468} 469 470static int prism2_ioctl_giwsens(struct net_device *dev, 471 struct iw_request_info *info, 472 struct iw_param *sens, char *extra) 473{ 474 struct hostap_interface *iface; 475 local_info_t *local; 476 __le16 val; 477 478 iface = netdev_priv(dev); 479 local = iface->local; 480 481 /* Get the current AP density */ 482 if (local->func->get_rid(dev, HFA384X_RID_CNFSYSTEMSCALE, &val, 2, 1) < 483 0) 484 return -EINVAL; 485 486 sens->value = le16_to_cpu(val); 487 sens->fixed = 1; 488 489 return 0; 490} 491 492 493/* Deprecated in new wireless extension API */ 494static int prism2_ioctl_giwaplist(struct net_device *dev, 495 struct iw_request_info *info, 496 struct iw_point *data, char *extra) 497{ 498 struct hostap_interface *iface; 499 local_info_t *local; 500 struct sockaddr *addr; 501 struct iw_quality *qual; 502 503 iface = netdev_priv(dev); 504 local = iface->local; 505 506 if (local->iw_mode != IW_MODE_MASTER) { 507 printk(KERN_DEBUG "SIOCGIWAPLIST is currently only supported " 508 "in Host AP mode\n"); 509 data->length = 0; 510 return -EOPNOTSUPP; 511 } 512 513 addr = kmalloc(sizeof(struct sockaddr) * IW_MAX_AP, GFP_KERNEL); 514 qual = kmalloc(sizeof(struct iw_quality) * IW_MAX_AP, GFP_KERNEL); 515 if (addr == NULL || qual == NULL) { 516 kfree(addr); 517 kfree(qual); 518 data->length = 0; 519 return -ENOMEM; 520 } 521 522 data->length = prism2_ap_get_sta_qual(local, addr, qual, IW_MAX_AP, 1); 523 524 memcpy(extra, &addr, sizeof(struct sockaddr) * data->length); 525 data->flags = 1; /* has quality information */ 526 memcpy(extra + sizeof(struct sockaddr) * data->length, &qual, 527 sizeof(struct iw_quality) * data->length); 528 529 kfree(addr); 530 kfree(qual); 531 return 0; 532} 533 534 535static int prism2_ioctl_siwrts(struct net_device *dev, 536 struct iw_request_info *info, 537 struct iw_param *rts, char *extra) 538{ 539 struct hostap_interface *iface; 540 local_info_t *local; 541 __le16 val; 542 543 iface = netdev_priv(dev); 544 local = iface->local; 545 546 if (rts->disabled) 547 val = cpu_to_le16(2347); 548 else if (rts->value < 0 || rts->value > 2347) 549 return -EINVAL; 550 else 551 val = cpu_to_le16(rts->value); 552 553 if (local->func->set_rid(dev, HFA384X_RID_RTSTHRESHOLD, &val, 2) || 554 local->func->reset_port(dev)) 555 return -EINVAL; 556 557 local->rts_threshold = rts->value; 558 559 return 0; 560} 561 562static int prism2_ioctl_giwrts(struct net_device *dev, 563 struct iw_request_info *info, 564 struct iw_param *rts, char *extra) 565{ 566 struct hostap_interface *iface; 567 local_info_t *local; 568 __le16 val; 569 570 iface = netdev_priv(dev); 571 local = iface->local; 572 573 if (local->func->get_rid(dev, HFA384X_RID_RTSTHRESHOLD, &val, 2, 1) < 574 0) 575 return -EINVAL; 576 577 rts->value = le16_to_cpu(val); 578 rts->disabled = (rts->value == 2347); 579 rts->fixed = 1; 580 581 return 0; 582} 583 584 585static int prism2_ioctl_siwfrag(struct net_device *dev, 586 struct iw_request_info *info, 587 struct iw_param *rts, char *extra) 588{ 589 struct hostap_interface *iface; 590 local_info_t *local; 591 __le16 val; 592 593 iface = netdev_priv(dev); 594 local = iface->local; 595 596 if (rts->disabled) 597 val = cpu_to_le16(2346); 598 else if (rts->value < 256 || rts->value > 2346) 599 return -EINVAL; 600 else 601 val = cpu_to_le16(rts->value & ~0x1); /* even numbers only */ 602 603 local->fragm_threshold = rts->value & ~0x1; 604 if (local->func->set_rid(dev, HFA384X_RID_FRAGMENTATIONTHRESHOLD, &val, 605 2) 606 || local->func->reset_port(dev)) 607 return -EINVAL; 608 609 return 0; 610} 611 612static int prism2_ioctl_giwfrag(struct net_device *dev, 613 struct iw_request_info *info, 614 struct iw_param *rts, char *extra) 615{ 616 struct hostap_interface *iface; 617 local_info_t *local; 618 __le16 val; 619 620 iface = netdev_priv(dev); 621 local = iface->local; 622 623 if (local->func->get_rid(dev, HFA384X_RID_FRAGMENTATIONTHRESHOLD, 624 &val, 2, 1) < 0) 625 return -EINVAL; 626 627 rts->value = le16_to_cpu(val); 628 rts->disabled = (rts->value == 2346); 629 rts->fixed = 1; 630 631 return 0; 632} 633 634 635#ifndef PRISM2_NO_STATION_MODES 636static int hostap_join_ap(struct net_device *dev) 637{ 638 struct hostap_interface *iface; 639 local_info_t *local; 640 struct hfa384x_join_request req; 641 unsigned long flags; 642 int i; 643 struct hfa384x_hostscan_result *entry; 644 645 iface = netdev_priv(dev); 646 local = iface->local; 647 648 memcpy(req.bssid, local->preferred_ap, ETH_ALEN); 649 req.channel = 0; 650 651 spin_lock_irqsave(&local->lock, flags); 652 for (i = 0; i < local->last_scan_results_count; i++) { 653 if (!local->last_scan_results) 654 break; 655 entry = &local->last_scan_results[i]; 656 if (memcmp(local->preferred_ap, entry->bssid, ETH_ALEN) == 0) { 657 req.channel = entry->chid; 658 break; 659 } 660 } 661 spin_unlock_irqrestore(&local->lock, flags); 662 663 if (local->func->set_rid(dev, HFA384X_RID_JOINREQUEST, &req, 664 sizeof(req))) { 665 printk(KERN_DEBUG "%s: JoinRequest %pM failed\n", 666 dev->name, local->preferred_ap); 667 return -1; 668 } 669 670 printk(KERN_DEBUG "%s: Trying to join BSSID %pM\n", 671 dev->name, local->preferred_ap); 672 673 return 0; 674} 675#endif /* PRISM2_NO_STATION_MODES */ 676 677 678static int prism2_ioctl_siwap(struct net_device *dev, 679 struct iw_request_info *info, 680 struct sockaddr *ap_addr, char *extra) 681{ 682#ifdef PRISM2_NO_STATION_MODES 683 return -EOPNOTSUPP; 684#else /* PRISM2_NO_STATION_MODES */ 685 struct hostap_interface *iface; 686 local_info_t *local; 687 688 iface = netdev_priv(dev); 689 local = iface->local; 690 691 memcpy(local->preferred_ap, &ap_addr->sa_data, ETH_ALEN); 692 693 if (local->host_roaming == 1 && local->iw_mode == IW_MODE_INFRA) { 694 struct hfa384x_scan_request scan_req; 695 memset(&scan_req, 0, sizeof(scan_req)); 696 scan_req.channel_list = cpu_to_le16(0x3fff); 697 scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS); 698 if (local->func->set_rid(dev, HFA384X_RID_SCANREQUEST, 699 &scan_req, sizeof(scan_req))) { 700 printk(KERN_DEBUG "%s: ScanResults request failed - " 701 "preferred AP delayed to next unsolicited " 702 "scan\n", dev->name); 703 } 704 } else if (local->host_roaming == 2 && 705 local->iw_mode == IW_MODE_INFRA) { 706 if (hostap_join_ap(dev)) 707 return -EINVAL; 708 } else { 709 printk(KERN_DEBUG "%s: Preferred AP (SIOCSIWAP) is used only " 710 "in Managed mode when host_roaming is enabled\n", 711 dev->name); 712 } 713 714 return 0; 715#endif /* PRISM2_NO_STATION_MODES */ 716} 717 718static int prism2_ioctl_giwap(struct net_device *dev, 719 struct iw_request_info *info, 720 struct sockaddr *ap_addr, char *extra) 721{ 722 struct hostap_interface *iface; 723 local_info_t *local; 724 725 iface = netdev_priv(dev); 726 local = iface->local; 727 728 ap_addr->sa_family = ARPHRD_ETHER; 729 switch (iface->type) { 730 case HOSTAP_INTERFACE_AP: 731 memcpy(&ap_addr->sa_data, dev->dev_addr, ETH_ALEN); 732 break; 733 case HOSTAP_INTERFACE_STA: 734 memcpy(&ap_addr->sa_data, local->assoc_ap_addr, ETH_ALEN); 735 break; 736 case HOSTAP_INTERFACE_WDS: 737 memcpy(&ap_addr->sa_data, iface->u.wds.remote_addr, ETH_ALEN); 738 break; 739 default: 740 if (local->func->get_rid(dev, HFA384X_RID_CURRENTBSSID, 741 &ap_addr->sa_data, ETH_ALEN, 1) < 0) 742 return -EOPNOTSUPP; 743 744 /* local->bssid is also updated in LinkStatus handler when in 745 * station mode */ 746 memcpy(local->bssid, &ap_addr->sa_data, ETH_ALEN); 747 break; 748 } 749 750 return 0; 751} 752 753 754static int prism2_ioctl_siwnickn(struct net_device *dev, 755 struct iw_request_info *info, 756 struct iw_point *data, char *nickname) 757{ 758 struct hostap_interface *iface; 759 local_info_t *local; 760 761 iface = netdev_priv(dev); 762 local = iface->local; 763 764 memset(local->name, 0, sizeof(local->name)); 765 memcpy(local->name, nickname, data->length); 766 local->name_set = 1; 767 768 if (hostap_set_string(dev, HFA384X_RID_CNFOWNNAME, local->name) || 769 local->func->reset_port(dev)) 770 return -EINVAL; 771 772 return 0; 773} 774 775static int prism2_ioctl_giwnickn(struct net_device *dev, 776 struct iw_request_info *info, 777 struct iw_point *data, char *nickname) 778{ 779 struct hostap_interface *iface; 780 local_info_t *local; 781 int len; 782 char name[MAX_NAME_LEN + 3]; 783 u16 val; 784 785 iface = netdev_priv(dev); 786 local = iface->local; 787 788 len = local->func->get_rid(dev, HFA384X_RID_CNFOWNNAME, 789 &name, MAX_NAME_LEN + 2, 0); 790 val = le16_to_cpu(*(__le16 *) name); 791 if (len > MAX_NAME_LEN + 2 || len < 0 || val > MAX_NAME_LEN) 792 return -EOPNOTSUPP; 793 794 name[val + 2] = '\0'; 795 data->length = val + 1; 796 memcpy(nickname, name + 2, val + 1); 797 798 return 0; 799} 800 801 802static int prism2_ioctl_siwfreq(struct net_device *dev, 803 struct iw_request_info *info, 804 struct iw_freq *freq, char *extra) 805{ 806 struct hostap_interface *iface; 807 local_info_t *local; 808 809 iface = netdev_priv(dev); 810 local = iface->local; 811 812 /* freq => chan. */ 813 if (freq->e == 1 && 814 freq->m / 100000 >= freq_list[0] && 815 freq->m / 100000 <= freq_list[FREQ_COUNT - 1]) { 816 int ch; 817 int fr = freq->m / 100000; 818 for (ch = 0; ch < FREQ_COUNT; ch++) { 819 if (fr == freq_list[ch]) { 820 freq->e = 0; 821 freq->m = ch + 1; 822 break; 823 } 824 } 825 } 826 827 if (freq->e != 0 || freq->m < 1 || freq->m > FREQ_COUNT || 828 !(local->channel_mask & (1 << (freq->m - 1)))) 829 return -EINVAL; 830 831 local->channel = freq->m; /* channel is used in prism2_setup_rids() */ 832 if (hostap_set_word(dev, HFA384X_RID_CNFOWNCHANNEL, local->channel) || 833 local->func->reset_port(dev)) 834 return -EINVAL; 835 836 return 0; 837} 838 839static int prism2_ioctl_giwfreq(struct net_device *dev, 840 struct iw_request_info *info, 841 struct iw_freq *freq, char *extra) 842{ 843 struct hostap_interface *iface; 844 local_info_t *local; 845 u16 val; 846 847 iface = netdev_priv(dev); 848 local = iface->local; 849 850 if (local->func->get_rid(dev, HFA384X_RID_CURRENTCHANNEL, &val, 2, 1) < 851 0) 852 return -EINVAL; 853 854 le16_to_cpus(&val); 855 if (val < 1 || val > FREQ_COUNT) 856 return -EINVAL; 857 858 freq->m = freq_list[val - 1] * 100000; 859 freq->e = 1; 860 861 return 0; 862} 863 864 865static void hostap_monitor_set_type(local_info_t *local) 866{ 867 struct net_device *dev = local->ddev; 868 869 if (dev == NULL) 870 return; 871 872 if (local->monitor_type == PRISM2_MONITOR_PRISM || 873 local->monitor_type == PRISM2_MONITOR_CAPHDR) { 874 dev->type = ARPHRD_IEEE80211_PRISM; 875 } else if (local->monitor_type == PRISM2_MONITOR_RADIOTAP) { 876 dev->type = ARPHRD_IEEE80211_RADIOTAP; 877 } else { 878 dev->type = ARPHRD_IEEE80211; 879 } 880} 881 882 883static int prism2_ioctl_siwessid(struct net_device *dev, 884 struct iw_request_info *info, 885 struct iw_point *data, char *ssid) 886{ 887 struct hostap_interface *iface; 888 local_info_t *local; 889 890 iface = netdev_priv(dev); 891 local = iface->local; 892 893 if (iface->type == HOSTAP_INTERFACE_WDS) 894 return -EOPNOTSUPP; 895 896 if (data->flags == 0) 897 ssid[0] = '\0'; /* ANY */ 898 899 if (local->iw_mode == IW_MODE_MASTER && ssid[0] == '\0') { 900 /* Setting SSID to empty string seems to kill the card in 901 * Host AP mode */ 902 printk(KERN_DEBUG "%s: Host AP mode does not support " 903 "'Any' essid\n", dev->name); 904 return -EINVAL; 905 } 906 907 memcpy(local->essid, ssid, data->length); 908 local->essid[data->length] = '\0'; 909 910 if ((!local->fw_ap && 911 hostap_set_string(dev, HFA384X_RID_CNFDESIREDSSID, local->essid)) 912 || hostap_set_string(dev, HFA384X_RID_CNFOWNSSID, local->essid) || 913 local->func->reset_port(dev)) 914 return -EINVAL; 915 916 return 0; 917} 918 919static int prism2_ioctl_giwessid(struct net_device *dev, 920 struct iw_request_info *info, 921 struct iw_point *data, char *essid) 922{ 923 struct hostap_interface *iface; 924 local_info_t *local; 925 u16 val; 926 927 iface = netdev_priv(dev); 928 local = iface->local; 929 930 if (iface->type == HOSTAP_INTERFACE_WDS) 931 return -EOPNOTSUPP; 932 933 data->flags = 1; /* active */ 934 if (local->iw_mode == IW_MODE_MASTER) { 935 data->length = strlen(local->essid); 936 memcpy(essid, local->essid, IW_ESSID_MAX_SIZE); 937 } else { 938 int len; 939 char ssid[MAX_SSID_LEN + 2]; 940 memset(ssid, 0, sizeof(ssid)); 941 len = local->func->get_rid(dev, HFA384X_RID_CURRENTSSID, 942 &ssid, MAX_SSID_LEN + 2, 0); 943 val = le16_to_cpu(*(__le16 *) ssid); 944 if (len > MAX_SSID_LEN + 2 || len < 0 || val > MAX_SSID_LEN) { 945 return -EOPNOTSUPP; 946 } 947 data->length = val; 948 memcpy(essid, ssid + 2, IW_ESSID_MAX_SIZE); 949 } 950 951 return 0; 952} 953 954 955static int prism2_ioctl_giwrange(struct net_device *dev, 956 struct iw_request_info *info, 957 struct iw_point *data, char *extra) 958{ 959 struct hostap_interface *iface; 960 local_info_t *local; 961 struct iw_range *range = (struct iw_range *) extra; 962 u8 rates[10]; 963 u16 val; 964 int i, len, over2; 965 966 iface = netdev_priv(dev); 967 local = iface->local; 968 969 data->length = sizeof(struct iw_range); 970 memset(range, 0, sizeof(struct iw_range)); 971 972 /* TODO: could fill num_txpower and txpower array with 973 * something; however, there are 128 different values.. */ 974 975 range->txpower_capa = IW_TXPOW_DBM; 976 977 if (local->iw_mode == IW_MODE_INFRA || local->iw_mode == IW_MODE_ADHOC) 978 { 979 range->min_pmp = 1 * 1024; 980 range->max_pmp = 65535 * 1024; 981 range->min_pmt = 1 * 1024; 982 range->max_pmt = 1000 * 1024; 983 range->pmp_flags = IW_POWER_PERIOD; 984 range->pmt_flags = IW_POWER_TIMEOUT; 985 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | 986 IW_POWER_UNICAST_R | IW_POWER_ALL_R; 987 } 988 989 range->we_version_compiled = WIRELESS_EXT; 990 range->we_version_source = 18; 991 992 range->retry_capa = IW_RETRY_LIMIT; 993 range->retry_flags = IW_RETRY_LIMIT; 994 range->min_retry = 0; 995 range->max_retry = 255; 996 997 range->num_channels = FREQ_COUNT; 998 999 val = 0; 1000 for (i = 0; i < FREQ_COUNT; i++) { 1001 if (local->channel_mask & (1 << i)) { 1002 range->freq[val].i = i + 1; 1003 range->freq[val].m = freq_list[i] * 100000; 1004 range->freq[val].e = 1; 1005 val++; 1006 } 1007 if (val == IW_MAX_FREQUENCIES) 1008 break; 1009 } 1010 range->num_frequency = val; 1011 1012 if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1)) { 1013 range->max_qual.qual = 70; /* what is correct max? This was not 1014 * documented exactly. At least 1015 * 69 has been observed. */ 1016 range->max_qual.level = 0; /* dB */ 1017 range->max_qual.noise = 0; /* dB */ 1018 1019 /* What would be suitable values for "average/typical" qual? */ 1020 range->avg_qual.qual = 20; 1021 range->avg_qual.level = -60; 1022 range->avg_qual.noise = -95; 1023 } else { 1024 range->max_qual.qual = 92; /* 0 .. 92 */ 1025 range->max_qual.level = 154; /* 27 .. 154 */ 1026 range->max_qual.noise = 154; /* 27 .. 154 */ 1027 } 1028 range->sensitivity = 3; 1029 1030 range->max_encoding_tokens = WEP_KEYS; 1031 range->num_encoding_sizes = 2; 1032 range->encoding_size[0] = 5; 1033 range->encoding_size[1] = 13; 1034 1035 over2 = 0; 1036 len = prism2_get_datarates(dev, rates); 1037 range->num_bitrates = 0; 1038 for (i = 0; i < len; i++) { 1039 if (range->num_bitrates < IW_MAX_BITRATES) { 1040 range->bitrate[range->num_bitrates] = 1041 rates[i] * 500000; 1042 range->num_bitrates++; 1043 } 1044 if (rates[i] == 0x0b || rates[i] == 0x16) 1045 over2 = 1; 1046 } 1047 /* estimated maximum TCP throughput values (bps) */ 1048 range->throughput = over2 ? 5500000 : 1500000; 1049 1050 range->min_rts = 0; 1051 range->max_rts = 2347; 1052 range->min_frag = 256; 1053 range->max_frag = 2346; 1054 1055 /* Event capability (kernel + driver) */ 1056 range->event_capa[0] = (IW_EVENT_CAPA_K_0 | 1057 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) | 1058 IW_EVENT_CAPA_MASK(SIOCGIWAP) | 1059 IW_EVENT_CAPA_MASK(SIOCGIWSCAN)); 1060 range->event_capa[1] = IW_EVENT_CAPA_K_1; 1061 range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVTXDROP) | 1062 IW_EVENT_CAPA_MASK(IWEVCUSTOM) | 1063 IW_EVENT_CAPA_MASK(IWEVREGISTERED) | 1064 IW_EVENT_CAPA_MASK(IWEVEXPIRED)); 1065 1066 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 1067 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP; 1068 1069 if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1)) 1070 range->scan_capa = IW_SCAN_CAPA_ESSID; 1071 1072 return 0; 1073} 1074 1075 1076static int hostap_monitor_mode_enable(local_info_t *local) 1077{ 1078 struct net_device *dev = local->dev; 1079 1080 printk(KERN_DEBUG "Enabling monitor mode\n"); 1081 hostap_monitor_set_type(local); 1082 1083 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE, 1084 HFA384X_PORTTYPE_PSEUDO_IBSS)) { 1085 printk(KERN_DEBUG "Port type setting for monitor mode " 1086 "failed\n"); 1087 return -EOPNOTSUPP; 1088 } 1089 1090 /* Host decrypt is needed to get the IV and ICV fields; 1091 * however, monitor mode seems to remove WEP flag from frame 1092 * control field */ 1093 if (hostap_set_word(dev, HFA384X_RID_CNFWEPFLAGS, 1094 HFA384X_WEPFLAGS_HOSTENCRYPT | 1095 HFA384X_WEPFLAGS_HOSTDECRYPT)) { 1096 printk(KERN_DEBUG "WEP flags setting failed\n"); 1097 return -EOPNOTSUPP; 1098 } 1099 1100 if (local->func->reset_port(dev) || 1101 local->func->cmd(dev, HFA384X_CMDCODE_TEST | 1102 (HFA384X_TEST_MONITOR << 8), 1103 0, NULL, NULL)) { 1104 printk(KERN_DEBUG "Setting monitor mode failed\n"); 1105 return -EOPNOTSUPP; 1106 } 1107 1108 return 0; 1109} 1110 1111 1112static int hostap_monitor_mode_disable(local_info_t *local) 1113{ 1114 struct net_device *dev = local->ddev; 1115 1116 if (dev == NULL) 1117 return -1; 1118 1119 printk(KERN_DEBUG "%s: Disabling monitor mode\n", dev->name); 1120 dev->type = ARPHRD_ETHER; 1121 1122 if (local->func->cmd(dev, HFA384X_CMDCODE_TEST | 1123 (HFA384X_TEST_STOP << 8), 1124 0, NULL, NULL)) 1125 return -1; 1126 return hostap_set_encryption(local); 1127} 1128 1129 1130static int prism2_ioctl_siwmode(struct net_device *dev, 1131 struct iw_request_info *info, 1132 __u32 *mode, char *extra) 1133{ 1134 struct hostap_interface *iface; 1135 local_info_t *local; 1136 int double_reset = 0; 1137 1138 iface = netdev_priv(dev); 1139 local = iface->local; 1140 1141 if (*mode != IW_MODE_ADHOC && *mode != IW_MODE_INFRA && 1142 *mode != IW_MODE_MASTER && *mode != IW_MODE_REPEAT && 1143 *mode != IW_MODE_MONITOR) 1144 return -EOPNOTSUPP; 1145 1146#ifdef PRISM2_NO_STATION_MODES 1147 if (*mode == IW_MODE_ADHOC || *mode == IW_MODE_INFRA) 1148 return -EOPNOTSUPP; 1149#endif /* PRISM2_NO_STATION_MODES */ 1150 1151 if (*mode == local->iw_mode) 1152 return 0; 1153 1154 if (*mode == IW_MODE_MASTER && local->essid[0] == '\0') { 1155 printk(KERN_WARNING "%s: empty SSID not allowed in Master " 1156 "mode\n", dev->name); 1157 return -EINVAL; 1158 } 1159 1160 if (local->iw_mode == IW_MODE_MONITOR) 1161 hostap_monitor_mode_disable(local); 1162 1163 if ((local->iw_mode == IW_MODE_ADHOC || 1164 local->iw_mode == IW_MODE_MONITOR) && *mode == IW_MODE_MASTER) { 1165 double_reset = 1; 1166 } 1167 1168 printk(KERN_DEBUG "prism2: %s: operating mode changed " 1169 "%d -> %d\n", dev->name, local->iw_mode, *mode); 1170 local->iw_mode = *mode; 1171 1172 if (local->iw_mode == IW_MODE_MONITOR) 1173 hostap_monitor_mode_enable(local); 1174 else if (local->iw_mode == IW_MODE_MASTER && !local->host_encrypt && 1175 !local->fw_encrypt_ok) { 1176 printk(KERN_DEBUG "%s: defaulting to host-based encryption as " 1177 "a workaround for firmware bug in Host AP mode WEP\n", 1178 dev->name); 1179 local->host_encrypt = 1; 1180 } 1181 1182 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE, 1183 hostap_get_porttype(local))) 1184 return -EOPNOTSUPP; 1185 1186 if (local->func->reset_port(dev)) 1187 return -EINVAL; 1188 if (double_reset && local->func->reset_port(dev)) 1189 return -EINVAL; 1190 1191 if (local->iw_mode != IW_MODE_INFRA && local->iw_mode != IW_MODE_ADHOC) 1192 { 1193 /* netif_carrier is used only in client modes for now, so make 1194 * sure carrier is on when moving to non-client modes. */ 1195 netif_carrier_on(local->dev); 1196 netif_carrier_on(local->ddev); 1197 } 1198 return 0; 1199} 1200 1201 1202static int prism2_ioctl_giwmode(struct net_device *dev, 1203 struct iw_request_info *info, 1204 __u32 *mode, char *extra) 1205{ 1206 struct hostap_interface *iface; 1207 local_info_t *local; 1208 1209 iface = netdev_priv(dev); 1210 local = iface->local; 1211 1212 switch (iface->type) { 1213 case HOSTAP_INTERFACE_STA: 1214 *mode = IW_MODE_INFRA; 1215 break; 1216 case HOSTAP_INTERFACE_WDS: 1217 *mode = IW_MODE_REPEAT; 1218 break; 1219 default: 1220 *mode = local->iw_mode; 1221 break; 1222 } 1223 return 0; 1224} 1225 1226 1227static int prism2_ioctl_siwpower(struct net_device *dev, 1228 struct iw_request_info *info, 1229 struct iw_param *wrq, char *extra) 1230{ 1231#ifdef PRISM2_NO_STATION_MODES 1232 return -EOPNOTSUPP; 1233#else /* PRISM2_NO_STATION_MODES */ 1234 int ret = 0; 1235 1236 if (wrq->disabled) 1237 return hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 0); 1238 1239 switch (wrq->flags & IW_POWER_MODE) { 1240 case IW_POWER_UNICAST_R: 1241 ret = hostap_set_word(dev, HFA384X_RID_CNFMULTICASTRECEIVE, 0); 1242 if (ret) 1243 return ret; 1244 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1); 1245 if (ret) 1246 return ret; 1247 break; 1248 case IW_POWER_ALL_R: 1249 ret = hostap_set_word(dev, HFA384X_RID_CNFMULTICASTRECEIVE, 1); 1250 if (ret) 1251 return ret; 1252 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1); 1253 if (ret) 1254 return ret; 1255 break; 1256 case IW_POWER_ON: 1257 break; 1258 default: 1259 return -EINVAL; 1260 } 1261 1262 if (wrq->flags & IW_POWER_TIMEOUT) { 1263 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1); 1264 if (ret) 1265 return ret; 1266 ret = hostap_set_word(dev, HFA384X_RID_CNFPMHOLDOVERDURATION, 1267 wrq->value / 1024); 1268 if (ret) 1269 return ret; 1270 } 1271 if (wrq->flags & IW_POWER_PERIOD) { 1272 ret = hostap_set_word(dev, HFA384X_RID_CNFPMENABLED, 1); 1273 if (ret) 1274 return ret; 1275 ret = hostap_set_word(dev, HFA384X_RID_CNFMAXSLEEPDURATION, 1276 wrq->value / 1024); 1277 if (ret) 1278 return ret; 1279 } 1280 1281 return ret; 1282#endif /* PRISM2_NO_STATION_MODES */ 1283} 1284 1285 1286static int prism2_ioctl_giwpower(struct net_device *dev, 1287 struct iw_request_info *info, 1288 struct iw_param *rrq, char *extra) 1289{ 1290#ifdef PRISM2_NO_STATION_MODES 1291 return -EOPNOTSUPP; 1292#else /* PRISM2_NO_STATION_MODES */ 1293 struct hostap_interface *iface; 1294 local_info_t *local; 1295 __le16 enable, mcast; 1296 1297 iface = netdev_priv(dev); 1298 local = iface->local; 1299 1300 if (local->func->get_rid(dev, HFA384X_RID_CNFPMENABLED, &enable, 2, 1) 1301 < 0) 1302 return -EINVAL; 1303 1304 if (!le16_to_cpu(enable)) { 1305 rrq->disabled = 1; 1306 return 0; 1307 } 1308 1309 rrq->disabled = 0; 1310 1311 if ((rrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) { 1312 __le16 timeout; 1313 if (local->func->get_rid(dev, 1314 HFA384X_RID_CNFPMHOLDOVERDURATION, 1315 &timeout, 2, 1) < 0) 1316 return -EINVAL; 1317 1318 rrq->flags = IW_POWER_TIMEOUT; 1319 rrq->value = le16_to_cpu(timeout) * 1024; 1320 } else { 1321 __le16 period; 1322 if (local->func->get_rid(dev, HFA384X_RID_CNFMAXSLEEPDURATION, 1323 &period, 2, 1) < 0) 1324 return -EINVAL; 1325 1326 rrq->flags = IW_POWER_PERIOD; 1327 rrq->value = le16_to_cpu(period) * 1024; 1328 } 1329 1330 if (local->func->get_rid(dev, HFA384X_RID_CNFMULTICASTRECEIVE, &mcast, 1331 2, 1) < 0) 1332 return -EINVAL; 1333 1334 if (le16_to_cpu(mcast)) 1335 rrq->flags |= IW_POWER_ALL_R; 1336 else 1337 rrq->flags |= IW_POWER_UNICAST_R; 1338 1339 return 0; 1340#endif /* PRISM2_NO_STATION_MODES */ 1341} 1342 1343 1344static int prism2_ioctl_siwretry(struct net_device *dev, 1345 struct iw_request_info *info, 1346 struct iw_param *rrq, char *extra) 1347{ 1348 struct hostap_interface *iface; 1349 local_info_t *local; 1350 1351 iface = netdev_priv(dev); 1352 local = iface->local; 1353 1354 if (rrq->disabled) 1355 return -EINVAL; 1356 1357 /* setting retry limits is not supported with the current station 1358 * firmware code; simulate this with alternative retry count for now */ 1359 if (rrq->flags == IW_RETRY_LIMIT) { 1360 if (rrq->value < 0) { 1361 /* disable manual retry count setting and use firmware 1362 * defaults */ 1363 local->manual_retry_count = -1; 1364 local->tx_control &= ~HFA384X_TX_CTRL_ALT_RTRY; 1365 } else { 1366 if (hostap_set_word(dev, HFA384X_RID_CNFALTRETRYCOUNT, 1367 rrq->value)) { 1368 printk(KERN_DEBUG "%s: Alternate retry count " 1369 "setting to %d failed\n", 1370 dev->name, rrq->value); 1371 return -EOPNOTSUPP; 1372 } 1373 1374 local->manual_retry_count = rrq->value; 1375 local->tx_control |= HFA384X_TX_CTRL_ALT_RTRY; 1376 } 1377 return 0; 1378 } 1379 1380 return -EOPNOTSUPP; 1381 1382} 1383 1384static int prism2_ioctl_giwretry(struct net_device *dev, 1385 struct iw_request_info *info, 1386 struct iw_param *rrq, char *extra) 1387{ 1388 struct hostap_interface *iface; 1389 local_info_t *local; 1390 __le16 shortretry, longretry, lifetime, altretry; 1391 1392 iface = netdev_priv(dev); 1393 local = iface->local; 1394 1395 if (local->func->get_rid(dev, HFA384X_RID_SHORTRETRYLIMIT, &shortretry, 1396 2, 1) < 0 || 1397 local->func->get_rid(dev, HFA384X_RID_LONGRETRYLIMIT, &longretry, 1398 2, 1) < 0 || 1399 local->func->get_rid(dev, HFA384X_RID_MAXTRANSMITLIFETIME, 1400 &lifetime, 2, 1) < 0) 1401 return -EINVAL; 1402 1403 rrq->disabled = 0; 1404 1405 if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) { 1406 rrq->flags = IW_RETRY_LIFETIME; 1407 rrq->value = le16_to_cpu(lifetime) * 1024; 1408 } else { 1409 if (local->manual_retry_count >= 0) { 1410 rrq->flags = IW_RETRY_LIMIT; 1411 if (local->func->get_rid(dev, 1412 HFA384X_RID_CNFALTRETRYCOUNT, 1413 &altretry, 2, 1) >= 0) 1414 rrq->value = le16_to_cpu(altretry); 1415 else 1416 rrq->value = local->manual_retry_count; 1417 } else if ((rrq->flags & IW_RETRY_LONG)) { 1418 rrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG; 1419 rrq->value = le16_to_cpu(longretry); 1420 } else { 1421 rrq->flags = IW_RETRY_LIMIT; 1422 rrq->value = le16_to_cpu(shortretry); 1423 if (shortretry != longretry) 1424 rrq->flags |= IW_RETRY_SHORT; 1425 } 1426 } 1427 return 0; 1428} 1429 1430 1431/* Note! This TX power controlling is experimental and should not be used in 1432 * production use. It just sets raw power register and does not use any kind of 1433 * feedback information from the measured TX power (CR58). This is now 1434 * commented out to make sure that it is not used by accident. TX power 1435 * configuration will be enabled again after proper algorithm using feedback 1436 * has been implemented. */ 1437 1438#ifdef RAW_TXPOWER_SETTING 1439/* Map HFA386x's CR31 to and from dBm with some sort of ad hoc mapping.. 1440 * This version assumes following mapping: 1441 * CR31 is 7-bit value with -64 to +63 range. 1442 * -64 is mapped into +20dBm and +63 into -43dBm. 1443 * This is certainly not an exact mapping for every card, but at least 1444 * increasing dBm value should correspond to increasing TX power. 1445 */ 1446 1447static int prism2_txpower_hfa386x_to_dBm(u16 val) 1448{ 1449 signed char tmp; 1450 1451 if (val > 255) 1452 val = 255; 1453 1454 tmp = val; 1455 tmp >>= 2; 1456 1457 return -12 - tmp; 1458} 1459 1460static u16 prism2_txpower_dBm_to_hfa386x(int val) 1461{ 1462 signed char tmp; 1463 1464 if (val > 20) 1465 return 128; 1466 else if (val < -43) 1467 return 127; 1468 1469 tmp = val; 1470 tmp = -12 - tmp; 1471 tmp <<= 2; 1472 1473 return (unsigned char) tmp; 1474} 1475#endif /* RAW_TXPOWER_SETTING */ 1476 1477 1478static int prism2_ioctl_siwtxpow(struct net_device *dev, 1479 struct iw_request_info *info, 1480 struct iw_param *rrq, char *extra) 1481{ 1482 struct hostap_interface *iface; 1483 local_info_t *local; 1484#ifdef RAW_TXPOWER_SETTING 1485 char *tmp; 1486#endif 1487 u16 val; 1488 int ret = 0; 1489 1490 iface = netdev_priv(dev); 1491 local = iface->local; 1492 1493 if (rrq->disabled) { 1494 if (local->txpower_type != PRISM2_TXPOWER_OFF) { 1495 val = 0xff; /* use all standby and sleep modes */ 1496 ret = local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF, 1497 HFA386X_CR_A_D_TEST_MODES2, 1498 &val, NULL); 1499 printk(KERN_DEBUG "%s: Turning radio off: %s\n", 1500 dev->name, ret ? "failed" : "OK"); 1501 local->txpower_type = PRISM2_TXPOWER_OFF; 1502 } 1503 return (ret ? -EOPNOTSUPP : 0); 1504 } 1505 1506 if (local->txpower_type == PRISM2_TXPOWER_OFF) { 1507 val = 0; /* disable all standby and sleep modes */ 1508 ret = local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF, 1509 HFA386X_CR_A_D_TEST_MODES2, &val, NULL); 1510 printk(KERN_DEBUG "%s: Turning radio on: %s\n", 1511 dev->name, ret ? "failed" : "OK"); 1512 local->txpower_type = PRISM2_TXPOWER_UNKNOWN; 1513 } 1514 1515#ifdef RAW_TXPOWER_SETTING 1516 if (!rrq->fixed && local->txpower_type != PRISM2_TXPOWER_AUTO) { 1517 printk(KERN_DEBUG "Setting ALC on\n"); 1518 val = HFA384X_TEST_CFG_BIT_ALC; 1519 local->func->cmd(dev, HFA384X_CMDCODE_TEST | 1520 (HFA384X_TEST_CFG_BITS << 8), 1, &val, NULL); 1521 local->txpower_type = PRISM2_TXPOWER_AUTO; 1522 return 0; 1523 } 1524 1525 if (local->txpower_type != PRISM2_TXPOWER_FIXED) { 1526 printk(KERN_DEBUG "Setting ALC off\n"); 1527 val = HFA384X_TEST_CFG_BIT_ALC; 1528 local->func->cmd(dev, HFA384X_CMDCODE_TEST | 1529 (HFA384X_TEST_CFG_BITS << 8), 0, &val, NULL); 1530 local->txpower_type = PRISM2_TXPOWER_FIXED; 1531 } 1532 1533 if (rrq->flags == IW_TXPOW_DBM) 1534 tmp = "dBm"; 1535 else if (rrq->flags == IW_TXPOW_MWATT) 1536 tmp = "mW"; 1537 else 1538 tmp = "UNKNOWN"; 1539 printk(KERN_DEBUG "Setting TX power to %d %s\n", rrq->value, tmp); 1540 1541 if (rrq->flags != IW_TXPOW_DBM) { 1542 printk("SIOCSIWTXPOW with mW is not supported; use dBm\n"); 1543 return -EOPNOTSUPP; 1544 } 1545 1546 local->txpower = rrq->value; 1547 val = prism2_txpower_dBm_to_hfa386x(local->txpower); 1548 if (local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF, 1549 HFA386X_CR_MANUAL_TX_POWER, &val, NULL)) 1550 ret = -EOPNOTSUPP; 1551#else /* RAW_TXPOWER_SETTING */ 1552 if (rrq->fixed) 1553 ret = -EOPNOTSUPP; 1554#endif /* RAW_TXPOWER_SETTING */ 1555 1556 return ret; 1557} 1558 1559static int prism2_ioctl_giwtxpow(struct net_device *dev, 1560 struct iw_request_info *info, 1561 struct iw_param *rrq, char *extra) 1562{ 1563#ifdef RAW_TXPOWER_SETTING 1564 struct hostap_interface *iface; 1565 local_info_t *local; 1566 u16 resp0; 1567 1568 iface = netdev_priv(dev); 1569 local = iface->local; 1570 1571 rrq->flags = IW_TXPOW_DBM; 1572 rrq->disabled = 0; 1573 rrq->fixed = 0; 1574 1575 if (local->txpower_type == PRISM2_TXPOWER_AUTO) { 1576 if (local->func->cmd(dev, HFA384X_CMDCODE_READMIF, 1577 HFA386X_CR_MANUAL_TX_POWER, 1578 NULL, &resp0) == 0) { 1579 rrq->value = prism2_txpower_hfa386x_to_dBm(resp0); 1580 } else { 1581 /* Could not get real txpower; guess 15 dBm */ 1582 rrq->value = 15; 1583 } 1584 } else if (local->txpower_type == PRISM2_TXPOWER_OFF) { 1585 rrq->value = 0; 1586 rrq->disabled = 1; 1587 } else if (local->txpower_type == PRISM2_TXPOWER_FIXED) { 1588 rrq->value = local->txpower; 1589 rrq->fixed = 1; 1590 } else { 1591 printk("SIOCGIWTXPOW - unknown txpower_type=%d\n", 1592 local->txpower_type); 1593 } 1594 return 0; 1595#else /* RAW_TXPOWER_SETTING */ 1596 return -EOPNOTSUPP; 1597#endif /* RAW_TXPOWER_SETTING */ 1598} 1599 1600 1601#ifndef PRISM2_NO_STATION_MODES 1602 1603/* HostScan request works with and without host_roaming mode. In addition, it 1604 * does not break current association. However, it requires newer station 1605 * firmware version (>= 1.3.1) than scan request. */ 1606static int prism2_request_hostscan(struct net_device *dev, 1607 u8 *ssid, u8 ssid_len) 1608{ 1609 struct hostap_interface *iface; 1610 local_info_t *local; 1611 struct hfa384x_hostscan_request scan_req; 1612 1613 iface = netdev_priv(dev); 1614 local = iface->local; 1615 1616 memset(&scan_req, 0, sizeof(scan_req)); 1617 scan_req.channel_list = cpu_to_le16(local->channel_mask & 1618 local->scan_channel_mask); 1619 scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS); 1620 if (ssid) { 1621 if (ssid_len > 32) 1622 return -EINVAL; 1623 scan_req.target_ssid_len = cpu_to_le16(ssid_len); 1624 memcpy(scan_req.target_ssid, ssid, ssid_len); 1625 } 1626 1627 if (local->func->set_rid(dev, HFA384X_RID_HOSTSCAN, &scan_req, 1628 sizeof(scan_req))) { 1629 printk(KERN_DEBUG "%s: HOSTSCAN failed\n", dev->name); 1630 return -EINVAL; 1631 } 1632 return 0; 1633} 1634 1635 1636static int prism2_request_scan(struct net_device *dev) 1637{ 1638 struct hostap_interface *iface; 1639 local_info_t *local; 1640 struct hfa384x_scan_request scan_req; 1641 int ret = 0; 1642 1643 iface = netdev_priv(dev); 1644 local = iface->local; 1645 1646 memset(&scan_req, 0, sizeof(scan_req)); 1647 scan_req.channel_list = cpu_to_le16(local->channel_mask & 1648 local->scan_channel_mask); 1649 scan_req.txrate = cpu_to_le16(HFA384X_RATES_1MBPS); 1650 1651 /* FIX: 1652 * It seems to be enough to set roaming mode for a short moment to 1653 * host-based and then setup scanrequest data and return the mode to 1654 * firmware-based. 1655 * 1656 * Master mode would need to drop to Managed mode for a short while 1657 * to make scanning work.. Or sweep through the different channels and 1658 * use passive scan based on beacons. */ 1659 1660 if (!local->host_roaming) 1661 hostap_set_word(dev, HFA384X_RID_CNFROAMINGMODE, 1662 HFA384X_ROAMING_HOST); 1663 1664 if (local->func->set_rid(dev, HFA384X_RID_SCANREQUEST, &scan_req, 1665 sizeof(scan_req))) { 1666 printk(KERN_DEBUG "SCANREQUEST failed\n"); 1667 ret = -EINVAL; 1668 } 1669 1670 if (!local->host_roaming) 1671 hostap_set_word(dev, HFA384X_RID_CNFROAMINGMODE, 1672 HFA384X_ROAMING_FIRMWARE); 1673 1674 return 0; 1675} 1676 1677#else /* !PRISM2_NO_STATION_MODES */ 1678 1679static inline int prism2_request_hostscan(struct net_device *dev, 1680 u8 *ssid, u8 ssid_len) 1681{ 1682 return -EOPNOTSUPP; 1683} 1684 1685 1686static inline int prism2_request_scan(struct net_device *dev) 1687{ 1688 return -EOPNOTSUPP; 1689} 1690 1691#endif /* !PRISM2_NO_STATION_MODES */ 1692 1693 1694static int prism2_ioctl_siwscan(struct net_device *dev, 1695 struct iw_request_info *info, 1696 struct iw_point *data, char *extra) 1697{ 1698 struct hostap_interface *iface; 1699 local_info_t *local; 1700 int ret; 1701 u8 *ssid = NULL, ssid_len = 0; 1702 struct iw_scan_req *req = (struct iw_scan_req *) extra; 1703 1704 iface = netdev_priv(dev); 1705 local = iface->local; 1706 1707 if (data->length < sizeof(struct iw_scan_req)) 1708 req = NULL; 1709 1710 if (local->iw_mode == IW_MODE_MASTER) { 1711 /* In master mode, we just return the results of our local 1712 * tables, so we don't need to start anything... 1713 * Jean II */ 1714 data->length = 0; 1715 return 0; 1716 } 1717 1718 if (!local->dev_enabled) 1719 return -ENETDOWN; 1720 1721 if (req && data->flags & IW_SCAN_THIS_ESSID) { 1722 ssid = req->essid; 1723 ssid_len = req->essid_len; 1724 1725 if (ssid_len && 1726 ((local->iw_mode != IW_MODE_INFRA && 1727 local->iw_mode != IW_MODE_ADHOC) || 1728 (local->sta_fw_ver < PRISM2_FW_VER(1,3,1)))) 1729 return -EOPNOTSUPP; 1730 } 1731 1732 if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1)) 1733 ret = prism2_request_hostscan(dev, ssid, ssid_len); 1734 else 1735 ret = prism2_request_scan(dev); 1736 1737 if (ret == 0) 1738 local->scan_timestamp = jiffies; 1739 1740 /* Could inquire F101, F103 or wait for SIOCGIWSCAN and read RID */ 1741 1742 return ret; 1743} 1744 1745 1746#ifndef PRISM2_NO_STATION_MODES 1747static char * __prism2_translate_scan(local_info_t *local, 1748 struct iw_request_info *info, 1749 struct hfa384x_hostscan_result *scan, 1750 struct hostap_bss_info *bss, 1751 char *current_ev, char *end_buf) 1752{ 1753 int i, chan; 1754 struct iw_event iwe; 1755 char *current_val; 1756 u16 capabilities; 1757 u8 *pos; 1758 u8 *ssid, *bssid; 1759 size_t ssid_len; 1760 char *buf; 1761 1762 if (bss) { 1763 ssid = bss->ssid; 1764 ssid_len = bss->ssid_len; 1765 bssid = bss->bssid; 1766 } else { 1767 ssid = scan->ssid; 1768 ssid_len = le16_to_cpu(scan->ssid_len); 1769 bssid = scan->bssid; 1770 } 1771 if (ssid_len > 32) 1772 ssid_len = 32; 1773 1774 /* First entry *MUST* be the AP MAC address */ 1775 memset(&iwe, 0, sizeof(iwe)); 1776 iwe.cmd = SIOCGIWAP; 1777 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 1778 memcpy(iwe.u.ap_addr.sa_data, bssid, ETH_ALEN); 1779 current_ev = iwe_stream_add_event(info, current_ev, end_buf, &iwe, 1780 IW_EV_ADDR_LEN); 1781 1782 /* Other entries will be displayed in the order we give them */ 1783 1784 memset(&iwe, 0, sizeof(iwe)); 1785 iwe.cmd = SIOCGIWESSID; 1786 iwe.u.data.length = ssid_len; 1787 iwe.u.data.flags = 1; 1788 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 1789 &iwe, ssid); 1790 1791 memset(&iwe, 0, sizeof(iwe)); 1792 iwe.cmd = SIOCGIWMODE; 1793 if (bss) { 1794 capabilities = bss->capab_info; 1795 } else { 1796 capabilities = le16_to_cpu(scan->capability); 1797 } 1798 if (capabilities & (WLAN_CAPABILITY_ESS | 1799 WLAN_CAPABILITY_IBSS)) { 1800 if (capabilities & WLAN_CAPABILITY_ESS) 1801 iwe.u.mode = IW_MODE_MASTER; 1802 else 1803 iwe.u.mode = IW_MODE_ADHOC; 1804 current_ev = iwe_stream_add_event(info, current_ev, end_buf, 1805 &iwe, IW_EV_UINT_LEN); 1806 } 1807 1808 memset(&iwe, 0, sizeof(iwe)); 1809 iwe.cmd = SIOCGIWFREQ; 1810 if (scan) { 1811 chan = le16_to_cpu(scan->chid); 1812 } else if (bss) { 1813 chan = bss->chan; 1814 } else { 1815 chan = 0; 1816 } 1817 1818 if (chan > 0) { 1819 iwe.u.freq.m = freq_list[chan - 1] * 100000; 1820 iwe.u.freq.e = 1; 1821 current_ev = iwe_stream_add_event(info, current_ev, end_buf, 1822 &iwe, IW_EV_FREQ_LEN); 1823 } 1824 1825 if (scan) { 1826 memset(&iwe, 0, sizeof(iwe)); 1827 iwe.cmd = IWEVQUAL; 1828 if (local->last_scan_type == PRISM2_HOSTSCAN) { 1829 iwe.u.qual.level = le16_to_cpu(scan->sl); 1830 iwe.u.qual.noise = le16_to_cpu(scan->anl); 1831 } else { 1832 iwe.u.qual.level = 1833 HFA384X_LEVEL_TO_dBm(le16_to_cpu(scan->sl)); 1834 iwe.u.qual.noise = 1835 HFA384X_LEVEL_TO_dBm(le16_to_cpu(scan->anl)); 1836 } 1837 iwe.u.qual.updated = IW_QUAL_LEVEL_UPDATED 1838 | IW_QUAL_NOISE_UPDATED 1839 | IW_QUAL_QUAL_INVALID 1840 | IW_QUAL_DBM; 1841 current_ev = iwe_stream_add_event(info, current_ev, end_buf, 1842 &iwe, IW_EV_QUAL_LEN); 1843 } 1844 1845 memset(&iwe, 0, sizeof(iwe)); 1846 iwe.cmd = SIOCGIWENCODE; 1847 if (capabilities & WLAN_CAPABILITY_PRIVACY) 1848 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; 1849 else 1850 iwe.u.data.flags = IW_ENCODE_DISABLED; 1851 iwe.u.data.length = 0; 1852 current_ev = iwe_stream_add_point(info, current_ev, end_buf, &iwe, ""); 1853 1854 /* TODO: add SuppRates into BSS table */ 1855 if (scan) { 1856 memset(&iwe, 0, sizeof(iwe)); 1857 iwe.cmd = SIOCGIWRATE; 1858 current_val = current_ev + iwe_stream_lcp_len(info); 1859 pos = scan->sup_rates; 1860 for (i = 0; i < sizeof(scan->sup_rates); i++) { 1861 if (pos[i] == 0) 1862 break; 1863 /* Bit rate given in 500 kb/s units (+ 0x80) */ 1864 iwe.u.bitrate.value = ((pos[i] & 0x7f) * 500000); 1865 current_val = iwe_stream_add_value( 1866 info, current_ev, current_val, end_buf, &iwe, 1867 IW_EV_PARAM_LEN); 1868 } 1869 /* Check if we added any event */ 1870 if ((current_val - current_ev) > iwe_stream_lcp_len(info)) 1871 current_ev = current_val; 1872 } 1873 1874 /* TODO: add BeaconInt,resp_rate,atim into BSS table */ 1875 buf = kmalloc(MAX_WPA_IE_LEN * 2 + 30, GFP_ATOMIC); 1876 if (buf && scan) { 1877 memset(&iwe, 0, sizeof(iwe)); 1878 iwe.cmd = IWEVCUSTOM; 1879 sprintf(buf, "bcn_int=%d", le16_to_cpu(scan->beacon_interval)); 1880 iwe.u.data.length = strlen(buf); 1881 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 1882 &iwe, buf); 1883 1884 memset(&iwe, 0, sizeof(iwe)); 1885 iwe.cmd = IWEVCUSTOM; 1886 sprintf(buf, "resp_rate=%d", le16_to_cpu(scan->rate)); 1887 iwe.u.data.length = strlen(buf); 1888 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 1889 &iwe, buf); 1890 1891 if (local->last_scan_type == PRISM2_HOSTSCAN && 1892 (capabilities & WLAN_CAPABILITY_IBSS)) { 1893 memset(&iwe, 0, sizeof(iwe)); 1894 iwe.cmd = IWEVCUSTOM; 1895 sprintf(buf, "atim=%d", le16_to_cpu(scan->atim)); 1896 iwe.u.data.length = strlen(buf); 1897 current_ev = iwe_stream_add_point(info, current_ev, 1898 end_buf, &iwe, buf); 1899 } 1900 } 1901 kfree(buf); 1902 1903 if (bss && bss->wpa_ie_len > 0 && bss->wpa_ie_len <= MAX_WPA_IE_LEN) { 1904 memset(&iwe, 0, sizeof(iwe)); 1905 iwe.cmd = IWEVGENIE; 1906 iwe.u.data.length = bss->wpa_ie_len; 1907 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 1908 &iwe, bss->wpa_ie); 1909 } 1910 1911 if (bss && bss->rsn_ie_len > 0 && bss->rsn_ie_len <= MAX_WPA_IE_LEN) { 1912 memset(&iwe, 0, sizeof(iwe)); 1913 iwe.cmd = IWEVGENIE; 1914 iwe.u.data.length = bss->rsn_ie_len; 1915 current_ev = iwe_stream_add_point(info, current_ev, end_buf, 1916 &iwe, bss->rsn_ie); 1917 } 1918 1919 return current_ev; 1920} 1921 1922 1923/* Translate scan data returned from the card to a card independant 1924 * format that the Wireless Tools will understand - Jean II */ 1925static inline int prism2_translate_scan(local_info_t *local, 1926 struct iw_request_info *info, 1927 char *buffer, int buflen) 1928{ 1929 struct hfa384x_hostscan_result *scan; 1930 int entry, hostscan; 1931 char *current_ev = buffer; 1932 char *end_buf = buffer + buflen; 1933 struct list_head *ptr; 1934 1935 spin_lock_bh(&local->lock); 1936 1937 list_for_each(ptr, &local->bss_list) { 1938 struct hostap_bss_info *bss; 1939 bss = list_entry(ptr, struct hostap_bss_info, list); 1940 bss->included = 0; 1941 } 1942 1943 hostscan = local->last_scan_type == PRISM2_HOSTSCAN; 1944 for (entry = 0; entry < local->last_scan_results_count; entry++) { 1945 int found = 0; 1946 scan = &local->last_scan_results[entry]; 1947 1948 /* Report every SSID if the AP is using multiple SSIDs. If no 1949 * BSS record is found (e.g., when WPA mode is disabled), 1950 * report the AP once. */ 1951 list_for_each(ptr, &local->bss_list) { 1952 struct hostap_bss_info *bss; 1953 bss = list_entry(ptr, struct hostap_bss_info, list); 1954 if (memcmp(bss->bssid, scan->bssid, ETH_ALEN) == 0) { 1955 bss->included = 1; 1956 current_ev = __prism2_translate_scan( 1957 local, info, scan, bss, current_ev, 1958 end_buf); 1959 found++; 1960 } 1961 } 1962 if (!found) { 1963 current_ev = __prism2_translate_scan( 1964 local, info, scan, NULL, current_ev, end_buf); 1965 } 1966 /* Check if there is space for one more entry */ 1967 if ((end_buf - current_ev) <= IW_EV_ADDR_LEN) { 1968 /* Ask user space to try again with a bigger buffer */ 1969 spin_unlock_bh(&local->lock); 1970 return -E2BIG; 1971 } 1972 } 1973 1974 /* Prism2 firmware has limits (32 at least in some versions) for number 1975 * of BSSes in scan results. Extend this limit by using local BSS list. 1976 */ 1977 list_for_each(ptr, &local->bss_list) { 1978 struct hostap_bss_info *bss; 1979 bss = list_entry(ptr, struct hostap_bss_info, list); 1980 if (bss->included) 1981 continue; 1982 current_ev = __prism2_translate_scan(local, info, NULL, bss, 1983 current_ev, end_buf); 1984 /* Check if there is space for one more entry */ 1985 if ((end_buf - current_ev) <= IW_EV_ADDR_LEN) { 1986 /* Ask user space to try again with a bigger buffer */ 1987 spin_unlock_bh(&local->lock); 1988 return -E2BIG; 1989 } 1990 } 1991 1992 spin_unlock_bh(&local->lock); 1993 1994 return current_ev - buffer; 1995} 1996#endif /* PRISM2_NO_STATION_MODES */ 1997 1998 1999static inline int prism2_ioctl_giwscan_sta(struct net_device *dev, 2000 struct iw_request_info *info, 2001 struct iw_point *data, char *extra) 2002{ 2003#ifdef PRISM2_NO_STATION_MODES 2004 return -EOPNOTSUPP; 2005#else /* PRISM2_NO_STATION_MODES */ 2006 struct hostap_interface *iface; 2007 local_info_t *local; 2008 int res; 2009 2010 iface = netdev_priv(dev); 2011 local = iface->local; 2012 2013 /* Wait until the scan is finished. We can probably do better 2014 * than that - Jean II */ 2015 if (local->scan_timestamp && 2016 time_before(jiffies, local->scan_timestamp + 3 * HZ)) { 2017 /* Important note : we don't want to block the caller 2018 * until results are ready for various reasons. 2019 * First, managing wait queues is complex and racy 2020 * (there may be multiple simultaneous callers). 2021 * Second, we grab some rtnetlink lock before comming 2022 * here (in dev_ioctl()). 2023 * Third, the caller can wait on the Wireless Event 2024 * - Jean II */ 2025 return -EAGAIN; 2026 } 2027 local->scan_timestamp = 0; 2028 2029 res = prism2_translate_scan(local, info, extra, data->length); 2030 2031 if (res >= 0) { 2032 data->length = res; 2033 return 0; 2034 } else { 2035 data->length = 0; 2036 return res; 2037 } 2038#endif /* PRISM2_NO_STATION_MODES */ 2039} 2040 2041 2042static int prism2_ioctl_giwscan(struct net_device *dev, 2043 struct iw_request_info *info, 2044 struct iw_point *data, char *extra) 2045{ 2046 struct hostap_interface *iface; 2047 local_info_t *local; 2048 int res; 2049 2050 iface = netdev_priv(dev); 2051 local = iface->local; 2052 2053 if (local->iw_mode == IW_MODE_MASTER) { 2054 /* In MASTER mode, it doesn't make sense to go around 2055 * scanning the frequencies and make the stations we serve 2056 * wait when what the user is really interested about is the 2057 * list of stations and access points we are talking to. 2058 * So, just extract results from our cache... 2059 * Jean II */ 2060 2061 /* Translate to WE format */ 2062 res = prism2_ap_translate_scan(dev, info, extra); 2063 if (res >= 0) { 2064 printk(KERN_DEBUG "Scan result translation succeeded " 2065 "(length=%d)\n", res); 2066 data->length = res; 2067 return 0; 2068 } else { 2069 printk(KERN_DEBUG 2070 "Scan result translation failed (res=%d)\n", 2071 res); 2072 data->length = 0; 2073 return res; 2074 } 2075 } else { 2076 /* Station mode */ 2077 return prism2_ioctl_giwscan_sta(dev, info, data, extra); 2078 } 2079} 2080 2081 2082static const struct iw_priv_args prism2_priv[] = { 2083 { PRISM2_IOCTL_MONITOR, 2084 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor" }, 2085 { PRISM2_IOCTL_READMIF, 2086 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 2087 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "readmif" }, 2088 { PRISM2_IOCTL_WRITEMIF, 2089 IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 2, 0, "writemif" }, 2090 { PRISM2_IOCTL_RESET, 2091 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "reset" }, 2092 { PRISM2_IOCTL_INQUIRE, 2093 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "inquire" }, 2094 { PRISM2_IOCTL_SET_RID_WORD, 2095 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "set_rid_word" }, 2096 { PRISM2_IOCTL_MACCMD, 2097 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "maccmd" }, 2098 { PRISM2_IOCTL_WDS_ADD, 2099 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_add" }, 2100 { PRISM2_IOCTL_WDS_DEL, 2101 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "wds_del" }, 2102 { PRISM2_IOCTL_ADDMAC, 2103 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "addmac" }, 2104 { PRISM2_IOCTL_DELMAC, 2105 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "delmac" }, 2106 { PRISM2_IOCTL_KICKMAC, 2107 IW_PRIV_TYPE_ADDR | IW_PRIV_SIZE_FIXED | 1, 0, "kickmac" }, 2108 /* --- raw access to sub-ioctls --- */ 2109 { PRISM2_IOCTL_PRISM2_PARAM, 2110 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "prism2_param" }, 2111 { PRISM2_IOCTL_GET_PRISM2_PARAM, 2112 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 2113 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprism2_param" }, 2114 /* --- sub-ioctls handlers --- */ 2115 { PRISM2_IOCTL_PRISM2_PARAM, 2116 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "" }, 2117 { PRISM2_IOCTL_GET_PRISM2_PARAM, 2118 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "" }, 2119 /* --- sub-ioctls definitions --- */ 2120 { PRISM2_PARAM_TXRATECTRL, 2121 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "txratectrl" }, 2122 { PRISM2_PARAM_TXRATECTRL, 2123 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettxratectrl" }, 2124 { PRISM2_PARAM_BEACON_INT, 2125 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "beacon_int" }, 2126 { PRISM2_PARAM_BEACON_INT, 2127 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbeacon_int" }, 2128#ifndef PRISM2_NO_STATION_MODES 2129 { PRISM2_PARAM_PSEUDO_IBSS, 2130 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "pseudo_ibss" }, 2131 { PRISM2_PARAM_PSEUDO_IBSS, 2132 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getpseudo_ibss" }, 2133#endif /* PRISM2_NO_STATION_MODES */ 2134 { PRISM2_PARAM_ALC, 2135 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "alc" }, 2136 { PRISM2_PARAM_ALC, 2137 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getalc" }, 2138 { PRISM2_PARAM_DUMP, 2139 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dump" }, 2140 { PRISM2_PARAM_DUMP, 2141 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdump" }, 2142 { PRISM2_PARAM_OTHER_AP_POLICY, 2143 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "other_ap_policy" }, 2144 { PRISM2_PARAM_OTHER_AP_POLICY, 2145 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getother_ap_pol" }, 2146 { PRISM2_PARAM_AP_MAX_INACTIVITY, 2147 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_inactivity" }, 2148 { PRISM2_PARAM_AP_MAX_INACTIVITY, 2149 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_inactivi" }, 2150 { PRISM2_PARAM_AP_BRIDGE_PACKETS, 2151 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bridge_packets" }, 2152 { PRISM2_PARAM_AP_BRIDGE_PACKETS, 2153 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbridge_packe" }, 2154 { PRISM2_PARAM_DTIM_PERIOD, 2155 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dtim_period" }, 2156 { PRISM2_PARAM_DTIM_PERIOD, 2157 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdtim_period" }, 2158 { PRISM2_PARAM_AP_NULLFUNC_ACK, 2159 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "nullfunc_ack" }, 2160 { PRISM2_PARAM_AP_NULLFUNC_ACK, 2161 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getnullfunc_ack" }, 2162 { PRISM2_PARAM_MAX_WDS, 2163 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "max_wds" }, 2164 { PRISM2_PARAM_MAX_WDS, 2165 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmax_wds" }, 2166 { PRISM2_PARAM_AP_AUTOM_AP_WDS, 2167 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "autom_ap_wds" }, 2168 { PRISM2_PARAM_AP_AUTOM_AP_WDS, 2169 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getautom_ap_wds" }, 2170 { PRISM2_PARAM_AP_AUTH_ALGS, 2171 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_auth_algs" }, 2172 { PRISM2_PARAM_AP_AUTH_ALGS, 2173 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_auth_algs" }, 2174 { PRISM2_PARAM_MONITOR_ALLOW_FCSERR, 2175 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "allow_fcserr" }, 2176 { PRISM2_PARAM_MONITOR_ALLOW_FCSERR, 2177 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getallow_fcserr" }, 2178 { PRISM2_PARAM_HOST_ENCRYPT, 2179 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_encrypt" }, 2180 { PRISM2_PARAM_HOST_ENCRYPT, 2181 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_encrypt" }, 2182 { PRISM2_PARAM_HOST_DECRYPT, 2183 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_decrypt" }, 2184 { PRISM2_PARAM_HOST_DECRYPT, 2185 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_decrypt" }, 2186#ifndef PRISM2_NO_STATION_MODES 2187 { PRISM2_PARAM_HOST_ROAMING, 2188 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "host_roaming" }, 2189 { PRISM2_PARAM_HOST_ROAMING, 2190 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethost_roaming" }, 2191#endif /* PRISM2_NO_STATION_MODES */ 2192 { PRISM2_PARAM_BCRX_STA_KEY, 2193 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "bcrx_sta_key" }, 2194 { PRISM2_PARAM_BCRX_STA_KEY, 2195 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbcrx_sta_key" }, 2196 { PRISM2_PARAM_IEEE_802_1X, 2197 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ieee_802_1x" }, 2198 { PRISM2_PARAM_IEEE_802_1X, 2199 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getieee_802_1x" }, 2200 { PRISM2_PARAM_ANTSEL_TX, 2201 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_tx" }, 2202 { PRISM2_PARAM_ANTSEL_TX, 2203 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_tx" }, 2204 { PRISM2_PARAM_ANTSEL_RX, 2205 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "antsel_rx" }, 2206 { PRISM2_PARAM_ANTSEL_RX, 2207 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getantsel_rx" }, 2208 { PRISM2_PARAM_MONITOR_TYPE, 2209 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "monitor_type" }, 2210 { PRISM2_PARAM_MONITOR_TYPE, 2211 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getmonitor_type" }, 2212 { PRISM2_PARAM_WDS_TYPE, 2213 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wds_type" }, 2214 { PRISM2_PARAM_WDS_TYPE, 2215 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwds_type" }, 2216 { PRISM2_PARAM_HOSTSCAN, 2217 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostscan" }, 2218 { PRISM2_PARAM_HOSTSCAN, 2219 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostscan" }, 2220 { PRISM2_PARAM_AP_SCAN, 2221 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "ap_scan" }, 2222 { PRISM2_PARAM_AP_SCAN, 2223 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getap_scan" }, 2224 { PRISM2_PARAM_ENH_SEC, 2225 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "enh_sec" }, 2226 { PRISM2_PARAM_ENH_SEC, 2227 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getenh_sec" }, 2228#ifdef PRISM2_IO_DEBUG 2229 { PRISM2_PARAM_IO_DEBUG, 2230 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "io_debug" }, 2231 { PRISM2_PARAM_IO_DEBUG, 2232 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getio_debug" }, 2233#endif /* PRISM2_IO_DEBUG */ 2234 { PRISM2_PARAM_BASIC_RATES, 2235 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "basic_rates" }, 2236 { PRISM2_PARAM_BASIC_RATES, 2237 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getbasic_rates" }, 2238 { PRISM2_PARAM_OPER_RATES, 2239 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "oper_rates" }, 2240 { PRISM2_PARAM_OPER_RATES, 2241 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getoper_rates" }, 2242 { PRISM2_PARAM_HOSTAPD, 2243 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd" }, 2244 { PRISM2_PARAM_HOSTAPD, 2245 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd" }, 2246 { PRISM2_PARAM_HOSTAPD_STA, 2247 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "hostapd_sta" }, 2248 { PRISM2_PARAM_HOSTAPD_STA, 2249 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gethostapd_sta" }, 2250 { PRISM2_PARAM_WPA, 2251 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wpa" }, 2252 { PRISM2_PARAM_WPA, 2253 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getwpa" }, 2254 { PRISM2_PARAM_PRIVACY_INVOKED, 2255 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "privacy_invoked" }, 2256 { PRISM2_PARAM_PRIVACY_INVOKED, 2257 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getprivacy_invo" }, 2258 { PRISM2_PARAM_TKIP_COUNTERMEASURES, 2259 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "tkip_countermea" }, 2260 { PRISM2_PARAM_TKIP_COUNTERMEASURES, 2261 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "gettkip_counter" }, 2262 { PRISM2_PARAM_DROP_UNENCRYPTED, 2263 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "drop_unencrypte" }, 2264 { PRISM2_PARAM_DROP_UNENCRYPTED, 2265 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getdrop_unencry" }, 2266 { PRISM2_PARAM_SCAN_CHANNEL_MASK, 2267 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "scan_channels" }, 2268 { PRISM2_PARAM_SCAN_CHANNEL_MASK, 2269 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "getscan_channel" }, 2270}; 2271 2272 2273static int prism2_ioctl_priv_inquire(struct net_device *dev, int *i) 2274{ 2275 struct hostap_interface *iface; 2276 local_info_t *local; 2277 2278 iface = netdev_priv(dev); 2279 local = iface->local; 2280 2281 if (local->func->cmd(dev, HFA384X_CMDCODE_INQUIRE, *i, NULL, NULL)) 2282 return -EOPNOTSUPP; 2283 2284 return 0; 2285} 2286 2287 2288static int prism2_ioctl_priv_prism2_param(struct net_device *dev, 2289 struct iw_request_info *info, 2290 void *wrqu, char *extra) 2291{ 2292 struct hostap_interface *iface; 2293 local_info_t *local; 2294 int *i = (int *) extra; 2295 int param = *i; 2296 int value = *(i + 1); 2297 int ret = 0; 2298 u16 val; 2299 2300 iface = netdev_priv(dev); 2301 local = iface->local; 2302 2303 switch (param) { 2304 case PRISM2_PARAM_TXRATECTRL: 2305 local->fw_tx_rate_control = value; 2306 break; 2307 2308 case PRISM2_PARAM_BEACON_INT: 2309 if (hostap_set_word(dev, HFA384X_RID_CNFBEACONINT, value) || 2310 local->func->reset_port(dev)) 2311 ret = -EINVAL; 2312 else 2313 local->beacon_int = value; 2314 break; 2315 2316#ifndef PRISM2_NO_STATION_MODES 2317 case PRISM2_PARAM_PSEUDO_IBSS: 2318 if (value == local->pseudo_adhoc) 2319 break; 2320 2321 if (value != 0 && value != 1) { 2322 ret = -EINVAL; 2323 break; 2324 } 2325 2326 printk(KERN_DEBUG "prism2: %s: pseudo IBSS change %d -> %d\n", 2327 dev->name, local->pseudo_adhoc, value); 2328 local->pseudo_adhoc = value; 2329 if (local->iw_mode != IW_MODE_ADHOC) 2330 break; 2331 2332 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE, 2333 hostap_get_porttype(local))) { 2334 ret = -EOPNOTSUPP; 2335 break; 2336 } 2337 2338 if (local->func->reset_port(dev)) 2339 ret = -EINVAL; 2340 break; 2341#endif /* PRISM2_NO_STATION_MODES */ 2342 2343 case PRISM2_PARAM_ALC: 2344 printk(KERN_DEBUG "%s: %s ALC\n", dev->name, 2345 value == 0 ? "Disabling" : "Enabling"); 2346 val = HFA384X_TEST_CFG_BIT_ALC; 2347 local->func->cmd(dev, HFA384X_CMDCODE_TEST | 2348 (HFA384X_TEST_CFG_BITS << 8), 2349 value == 0 ? 0 : 1, &val, NULL); 2350 break; 2351 2352 case PRISM2_PARAM_DUMP: 2353 local->frame_dump = value; 2354 break; 2355 2356 case PRISM2_PARAM_OTHER_AP_POLICY: 2357 if (value < 0 || value > 3) { 2358 ret = -EINVAL; 2359 break; 2360 } 2361 if (local->ap != NULL) 2362 local->ap->ap_policy = value; 2363 break; 2364 2365 case PRISM2_PARAM_AP_MAX_INACTIVITY: 2366 if (value < 0 || value > 7 * 24 * 60 * 60) { 2367 ret = -EINVAL; 2368 break; 2369 } 2370 if (local->ap != NULL) 2371 local->ap->max_inactivity = value * HZ; 2372 break; 2373 2374 case PRISM2_PARAM_AP_BRIDGE_PACKETS: 2375 if (local->ap != NULL) 2376 local->ap->bridge_packets = value; 2377 break; 2378 2379 case PRISM2_PARAM_DTIM_PERIOD: 2380 if (value < 0 || value > 65535) { 2381 ret = -EINVAL; 2382 break; 2383 } 2384 if (hostap_set_word(dev, HFA384X_RID_CNFOWNDTIMPERIOD, value) 2385 || local->func->reset_port(dev)) 2386 ret = -EINVAL; 2387 else 2388 local->dtim_period = value; 2389 break; 2390 2391 case PRISM2_PARAM_AP_NULLFUNC_ACK: 2392 if (local->ap != NULL) 2393 local->ap->nullfunc_ack = value; 2394 break; 2395 2396 case PRISM2_PARAM_MAX_WDS: 2397 local->wds_max_connections = value; 2398 break; 2399 2400 case PRISM2_PARAM_AP_AUTOM_AP_WDS: 2401 if (local->ap != NULL) { 2402 if (!local->ap->autom_ap_wds && value) { 2403 /* add WDS link to all APs in STA table */ 2404 hostap_add_wds_links(local); 2405 } 2406 local->ap->autom_ap_wds = value; 2407 } 2408 break; 2409 2410 case PRISM2_PARAM_AP_AUTH_ALGS: 2411 local->auth_algs = value; 2412 if (hostap_set_auth_algs(local)) 2413 ret = -EINVAL; 2414 break; 2415 2416 case PRISM2_PARAM_MONITOR_ALLOW_FCSERR: 2417 local->monitor_allow_fcserr = value; 2418 break; 2419 2420 case PRISM2_PARAM_HOST_ENCRYPT: 2421 local->host_encrypt = value; 2422 if (hostap_set_encryption(local) || 2423 local->func->reset_port(dev)) 2424 ret = -EINVAL; 2425 break; 2426 2427 case PRISM2_PARAM_HOST_DECRYPT: 2428 local->host_decrypt = value; 2429 if (hostap_set_encryption(local) || 2430 local->func->reset_port(dev)) 2431 ret = -EINVAL; 2432 break; 2433 2434#ifndef PRISM2_NO_STATION_MODES 2435 case PRISM2_PARAM_HOST_ROAMING: 2436 if (value < 0 || value > 2) { 2437 ret = -EINVAL; 2438 break; 2439 } 2440 local->host_roaming = value; 2441 if (hostap_set_roaming(local) || local->func->reset_port(dev)) 2442 ret = -EINVAL; 2443 break; 2444#endif /* PRISM2_NO_STATION_MODES */ 2445 2446 case PRISM2_PARAM_BCRX_STA_KEY: 2447 local->bcrx_sta_key = value; 2448 break; 2449 2450 case PRISM2_PARAM_IEEE_802_1X: 2451 local->ieee_802_1x = value; 2452 break; 2453 2454 case PRISM2_PARAM_ANTSEL_TX: 2455 if (value < 0 || value > HOSTAP_ANTSEL_HIGH) { 2456 ret = -EINVAL; 2457 break; 2458 } 2459 local->antsel_tx = value; 2460 hostap_set_antsel(local); 2461 break; 2462 2463 case PRISM2_PARAM_ANTSEL_RX: 2464 if (value < 0 || value > HOSTAP_ANTSEL_HIGH) { 2465 ret = -EINVAL; 2466 break; 2467 } 2468 local->antsel_rx = value; 2469 hostap_set_antsel(local); 2470 break; 2471 2472 case PRISM2_PARAM_MONITOR_TYPE: 2473 if (value != PRISM2_MONITOR_80211 && 2474 value != PRISM2_MONITOR_CAPHDR && 2475 value != PRISM2_MONITOR_PRISM && 2476 value != PRISM2_MONITOR_RADIOTAP) { 2477 ret = -EINVAL; 2478 break; 2479 } 2480 local->monitor_type = value; 2481 if (local->iw_mode == IW_MODE_MONITOR) 2482 hostap_monitor_set_type(local); 2483 break; 2484 2485 case PRISM2_PARAM_WDS_TYPE: 2486 local->wds_type = value; 2487 break; 2488 2489 case PRISM2_PARAM_HOSTSCAN: 2490 { 2491 struct hfa384x_hostscan_request scan_req; 2492 u16 rate; 2493 2494 memset(&scan_req, 0, sizeof(scan_req)); 2495 scan_req.channel_list = cpu_to_le16(0x3fff); 2496 switch (value) { 2497 case 1: rate = HFA384X_RATES_1MBPS; break; 2498 case 2: rate = HFA384X_RATES_2MBPS; break; 2499 case 3: rate = HFA384X_RATES_5MBPS; break; 2500 case 4: rate = HFA384X_RATES_11MBPS; break; 2501 default: rate = HFA384X_RATES_1MBPS; break; 2502 } 2503 scan_req.txrate = cpu_to_le16(rate); 2504 /* leave SSID empty to accept all SSIDs */ 2505 2506 if (local->iw_mode == IW_MODE_MASTER) { 2507 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE, 2508 HFA384X_PORTTYPE_BSS) || 2509 local->func->reset_port(dev)) 2510 printk(KERN_DEBUG "Leaving Host AP mode " 2511 "for HostScan failed\n"); 2512 } 2513 2514 if (local->func->set_rid(dev, HFA384X_RID_HOSTSCAN, &scan_req, 2515 sizeof(scan_req))) { 2516 printk(KERN_DEBUG "HOSTSCAN failed\n"); 2517 ret = -EINVAL; 2518 } 2519 if (local->iw_mode == IW_MODE_MASTER) { 2520 wait_queue_t __wait; 2521 init_waitqueue_entry(&__wait, current); 2522 add_wait_queue(&local->hostscan_wq, &__wait); 2523 set_current_state(TASK_INTERRUPTIBLE); 2524 schedule_timeout(HZ); 2525 if (signal_pending(current)) 2526 ret = -EINTR; 2527 set_current_state(TASK_RUNNING); 2528 remove_wait_queue(&local->hostscan_wq, &__wait); 2529 2530 if (hostap_set_word(dev, HFA384X_RID_CNFPORTTYPE, 2531 HFA384X_PORTTYPE_HOSTAP) || 2532 local->func->reset_port(dev)) 2533 printk(KERN_DEBUG "Returning to Host AP mode " 2534 "after HostScan failed\n"); 2535 } 2536 break; 2537 } 2538 2539 case PRISM2_PARAM_AP_SCAN: 2540 local->passive_scan_interval = value; 2541 if (timer_pending(&local->passive_scan_timer)) 2542 del_timer(&local->passive_scan_timer); 2543 if (value > 0) { 2544 local->passive_scan_timer.expires = jiffies + 2545 local->passive_scan_interval * HZ; 2546 add_timer(&local->passive_scan_timer); 2547 } 2548 break; 2549 2550 case PRISM2_PARAM_ENH_SEC: 2551 if (value < 0 || value > 3) { 2552 ret = -EINVAL; 2553 break; 2554 } 2555 local->enh_sec = value; 2556 if (hostap_set_word(dev, HFA384X_RID_CNFENHSECURITY, 2557 local->enh_sec) || 2558 local->func->reset_port(dev)) { 2559 printk(KERN_INFO "%s: cnfEnhSecurity requires STA f/w " 2560 "1.6.3 or newer\n", dev->name); 2561 ret = -EOPNOTSUPP; 2562 } 2563 break; 2564 2565#ifdef PRISM2_IO_DEBUG 2566 case PRISM2_PARAM_IO_DEBUG: 2567 local->io_debug_enabled = value; 2568 break; 2569#endif /* PRISM2_IO_DEBUG */ 2570 2571 case PRISM2_PARAM_BASIC_RATES: 2572 if ((value & local->tx_rate_control) != value || value == 0) { 2573 printk(KERN_INFO "%s: invalid basic rate set - basic " 2574 "rates must be in supported rate set\n", 2575 dev->name); 2576 ret = -EINVAL; 2577 break; 2578 } 2579 local->basic_rates = value; 2580 if (hostap_set_word(dev, HFA384X_RID_CNFBASICRATES, 2581 local->basic_rates) || 2582 local->func->reset_port(dev)) 2583 ret = -EINVAL; 2584 break; 2585 2586 case PRISM2_PARAM_OPER_RATES: 2587 local->tx_rate_control = value; 2588 if (hostap_set_rate(dev)) 2589 ret = -EINVAL; 2590 break; 2591 2592 case PRISM2_PARAM_HOSTAPD: 2593 ret = hostap_set_hostapd(local, value, 1); 2594 break; 2595 2596 case PRISM2_PARAM_HOSTAPD_STA: 2597 ret = hostap_set_hostapd_sta(local, value, 1); 2598 break; 2599 2600 case PRISM2_PARAM_WPA: 2601 local->wpa = value; 2602 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0)) 2603 ret = -EOPNOTSUPP; 2604 else if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE, 2605 value ? 1 : 0)) 2606 ret = -EINVAL; 2607 break; 2608 2609 case PRISM2_PARAM_PRIVACY_INVOKED: 2610 local->privacy_invoked = value; 2611 if (hostap_set_encryption(local) || 2612 local->func->reset_port(dev)) 2613 ret = -EINVAL; 2614 break; 2615 2616 case PRISM2_PARAM_TKIP_COUNTERMEASURES: 2617 local->tkip_countermeasures = value; 2618 break; 2619 2620 case PRISM2_PARAM_DROP_UNENCRYPTED: 2621 local->drop_unencrypted = value; 2622 break; 2623 2624 case PRISM2_PARAM_SCAN_CHANNEL_MASK: 2625 local->scan_channel_mask = value; 2626 break; 2627 2628 default: 2629 printk(KERN_DEBUG "%s: prism2_param: unknown param %d\n", 2630 dev->name, param); 2631 ret = -EOPNOTSUPP; 2632 break; 2633 } 2634 2635 return ret; 2636} 2637 2638 2639static int prism2_ioctl_priv_get_prism2_param(struct net_device *dev, 2640 struct iw_request_info *info, 2641 void *wrqu, char *extra) 2642{ 2643 struct hostap_interface *iface; 2644 local_info_t *local; 2645 int *param = (int *) extra; 2646 int ret = 0; 2647 2648 iface = netdev_priv(dev); 2649 local = iface->local; 2650 2651 switch (*param) { 2652 case PRISM2_PARAM_TXRATECTRL: 2653 *param = local->fw_tx_rate_control; 2654 break; 2655 2656 case PRISM2_PARAM_BEACON_INT: 2657 *param = local->beacon_int; 2658 break; 2659 2660 case PRISM2_PARAM_PSEUDO_IBSS: 2661 *param = local->pseudo_adhoc; 2662 break; 2663 2664 case PRISM2_PARAM_ALC: 2665 ret = -EOPNOTSUPP; /* FIX */ 2666 break; 2667 2668 case PRISM2_PARAM_DUMP: 2669 *param = local->frame_dump; 2670 break; 2671 2672 case PRISM2_PARAM_OTHER_AP_POLICY: 2673 if (local->ap != NULL) 2674 *param = local->ap->ap_policy; 2675 else 2676 ret = -EOPNOTSUPP; 2677 break; 2678 2679 case PRISM2_PARAM_AP_MAX_INACTIVITY: 2680 if (local->ap != NULL) 2681 *param = local->ap->max_inactivity / HZ; 2682 else 2683 ret = -EOPNOTSUPP; 2684 break; 2685 2686 case PRISM2_PARAM_AP_BRIDGE_PACKETS: 2687 if (local->ap != NULL) 2688 *param = local->ap->bridge_packets; 2689 else 2690 ret = -EOPNOTSUPP; 2691 break; 2692 2693 case PRISM2_PARAM_DTIM_PERIOD: 2694 *param = local->dtim_period; 2695 break; 2696 2697 case PRISM2_PARAM_AP_NULLFUNC_ACK: 2698 if (local->ap != NULL) 2699 *param = local->ap->nullfunc_ack; 2700 else 2701 ret = -EOPNOTSUPP; 2702 break; 2703 2704 case PRISM2_PARAM_MAX_WDS: 2705 *param = local->wds_max_connections; 2706 break; 2707 2708 case PRISM2_PARAM_AP_AUTOM_AP_WDS: 2709 if (local->ap != NULL) 2710 *param = local->ap->autom_ap_wds; 2711 else 2712 ret = -EOPNOTSUPP; 2713 break; 2714 2715 case PRISM2_PARAM_AP_AUTH_ALGS: 2716 *param = local->auth_algs; 2717 break; 2718 2719 case PRISM2_PARAM_MONITOR_ALLOW_FCSERR: 2720 *param = local->monitor_allow_fcserr; 2721 break; 2722 2723 case PRISM2_PARAM_HOST_ENCRYPT: 2724 *param = local->host_encrypt; 2725 break; 2726 2727 case PRISM2_PARAM_HOST_DECRYPT: 2728 *param = local->host_decrypt; 2729 break; 2730 2731 case PRISM2_PARAM_HOST_ROAMING: 2732 *param = local->host_roaming; 2733 break; 2734 2735 case PRISM2_PARAM_BCRX_STA_KEY: 2736 *param = local->bcrx_sta_key; 2737 break; 2738 2739 case PRISM2_PARAM_IEEE_802_1X: 2740 *param = local->ieee_802_1x; 2741 break; 2742 2743 case PRISM2_PARAM_ANTSEL_TX: 2744 *param = local->antsel_tx; 2745 break; 2746 2747 case PRISM2_PARAM_ANTSEL_RX: 2748 *param = local->antsel_rx; 2749 break; 2750 2751 case PRISM2_PARAM_MONITOR_TYPE: 2752 *param = local->monitor_type; 2753 break; 2754 2755 case PRISM2_PARAM_WDS_TYPE: 2756 *param = local->wds_type; 2757 break; 2758 2759 case PRISM2_PARAM_HOSTSCAN: 2760 ret = -EOPNOTSUPP; 2761 break; 2762 2763 case PRISM2_PARAM_AP_SCAN: 2764 *param = local->passive_scan_interval; 2765 break; 2766 2767 case PRISM2_PARAM_ENH_SEC: 2768 *param = local->enh_sec; 2769 break; 2770 2771#ifdef PRISM2_IO_DEBUG 2772 case PRISM2_PARAM_IO_DEBUG: 2773 *param = local->io_debug_enabled; 2774 break; 2775#endif /* PRISM2_IO_DEBUG */ 2776 2777 case PRISM2_PARAM_BASIC_RATES: 2778 *param = local->basic_rates; 2779 break; 2780 2781 case PRISM2_PARAM_OPER_RATES: 2782 *param = local->tx_rate_control; 2783 break; 2784 2785 case PRISM2_PARAM_HOSTAPD: 2786 *param = local->hostapd; 2787 break; 2788 2789 case PRISM2_PARAM_HOSTAPD_STA: 2790 *param = local->hostapd_sta; 2791 break; 2792 2793 case PRISM2_PARAM_WPA: 2794 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0)) 2795 ret = -EOPNOTSUPP; 2796 *param = local->wpa; 2797 break; 2798 2799 case PRISM2_PARAM_PRIVACY_INVOKED: 2800 *param = local->privacy_invoked; 2801 break; 2802 2803 case PRISM2_PARAM_TKIP_COUNTERMEASURES: 2804 *param = local->tkip_countermeasures; 2805 break; 2806 2807 case PRISM2_PARAM_DROP_UNENCRYPTED: 2808 *param = local->drop_unencrypted; 2809 break; 2810 2811 case PRISM2_PARAM_SCAN_CHANNEL_MASK: 2812 *param = local->scan_channel_mask; 2813 break; 2814 2815 default: 2816 printk(KERN_DEBUG "%s: get_prism2_param: unknown param %d\n", 2817 dev->name, *param); 2818 ret = -EOPNOTSUPP; 2819 break; 2820 } 2821 2822 return ret; 2823} 2824 2825 2826static int prism2_ioctl_priv_readmif(struct net_device *dev, 2827 struct iw_request_info *info, 2828 void *wrqu, char *extra) 2829{ 2830 struct hostap_interface *iface; 2831 local_info_t *local; 2832 u16 resp0; 2833 2834 iface = netdev_priv(dev); 2835 local = iface->local; 2836 2837 if (local->func->cmd(dev, HFA384X_CMDCODE_READMIF, *extra, NULL, 2838 &resp0)) 2839 return -EOPNOTSUPP; 2840 else 2841 *extra = resp0; 2842 2843 return 0; 2844} 2845 2846 2847static int prism2_ioctl_priv_writemif(struct net_device *dev, 2848 struct iw_request_info *info, 2849 void *wrqu, char *extra) 2850{ 2851 struct hostap_interface *iface; 2852 local_info_t *local; 2853 u16 cr, val; 2854 2855 iface = netdev_priv(dev); 2856 local = iface->local; 2857 2858 cr = *extra; 2859 val = *(extra + 1); 2860 if (local->func->cmd(dev, HFA384X_CMDCODE_WRITEMIF, cr, &val, NULL)) 2861 return -EOPNOTSUPP; 2862 2863 return 0; 2864} 2865 2866 2867static int prism2_ioctl_priv_monitor(struct net_device *dev, int *i) 2868{ 2869 struct hostap_interface *iface; 2870 local_info_t *local; 2871 int ret = 0; 2872 u32 mode; 2873 2874 iface = netdev_priv(dev); 2875 local = iface->local; 2876 2877 printk(KERN_DEBUG "%s: process %d (%s) used deprecated iwpriv monitor " 2878 "- update software to use iwconfig mode monitor\n", 2879 dev->name, task_pid_nr(current), current->comm); 2880 2881 /* Backward compatibility code - this can be removed at some point */ 2882 2883 if (*i == 0) { 2884 /* Disable monitor mode - old mode was not saved, so go to 2885 * Master mode */ 2886 mode = IW_MODE_MASTER; 2887 ret = prism2_ioctl_siwmode(dev, NULL, &mode, NULL); 2888 } else if (*i == 1) { 2889 /* netlink socket mode is not supported anymore since it did 2890 * not separate different devices from each other and was not 2891 * best method for delivering large amount of packets to 2892 * user space */ 2893 ret = -EOPNOTSUPP; 2894 } else if (*i == 2 || *i == 3) { 2895 switch (*i) { 2896 case 2: 2897 local->monitor_type = PRISM2_MONITOR_80211; 2898 break; 2899 case 3: 2900 local->monitor_type = PRISM2_MONITOR_PRISM; 2901 break; 2902 } 2903 mode = IW_MODE_MONITOR; 2904 ret = prism2_ioctl_siwmode(dev, NULL, &mode, NULL); 2905 hostap_monitor_mode_enable(local); 2906 } else 2907 ret = -EINVAL; 2908 2909 return ret; 2910} 2911 2912 2913static int prism2_ioctl_priv_reset(struct net_device *dev, int *i) 2914{ 2915 struct hostap_interface *iface; 2916 local_info_t *local; 2917 2918 iface = netdev_priv(dev); 2919 local = iface->local; 2920 2921 printk(KERN_DEBUG "%s: manual reset request(%d)\n", dev->name, *i); 2922 switch (*i) { 2923 case 0: 2924 /* Disable and enable card */ 2925 local->func->hw_shutdown(dev, 1); 2926 local->func->hw_config(dev, 0); 2927 break; 2928 2929 case 1: 2930 /* COR sreset */ 2931 local->func->hw_reset(dev); 2932 break; 2933 2934 case 2: 2935 /* Disable and enable port 0 */ 2936 local->func->reset_port(dev); 2937 break; 2938 2939 case 3: 2940 prism2_sta_deauth(local, WLAN_REASON_DEAUTH_LEAVING); 2941 if (local->func->cmd(dev, HFA384X_CMDCODE_DISABLE, 0, NULL, 2942 NULL)) 2943 return -EINVAL; 2944 break; 2945 2946 case 4: 2947 if (local->func->cmd(dev, HFA384X_CMDCODE_ENABLE, 0, NULL, 2948 NULL)) 2949 return -EINVAL; 2950 break; 2951 2952 default: 2953 printk(KERN_DEBUG "Unknown reset request %d\n", *i); 2954 return -EOPNOTSUPP; 2955 } 2956 2957 return 0; 2958} 2959 2960 2961static int prism2_ioctl_priv_set_rid_word(struct net_device *dev, int *i) 2962{ 2963 int rid = *i; 2964 int value = *(i + 1); 2965 2966 printk(KERN_DEBUG "%s: Set RID[0x%X] = %d\n", dev->name, rid, value); 2967 2968 if (hostap_set_word(dev, rid, value)) 2969 return -EINVAL; 2970 2971 return 0; 2972} 2973 2974 2975#ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT 2976static int ap_mac_cmd_ioctl(local_info_t *local, int *cmd) 2977{ 2978 int ret = 0; 2979 2980 switch (*cmd) { 2981 case AP_MAC_CMD_POLICY_OPEN: 2982 local->ap->mac_restrictions.policy = MAC_POLICY_OPEN; 2983 break; 2984 case AP_MAC_CMD_POLICY_ALLOW: 2985 local->ap->mac_restrictions.policy = MAC_POLICY_ALLOW; 2986 break; 2987 case AP_MAC_CMD_POLICY_DENY: 2988 local->ap->mac_restrictions.policy = MAC_POLICY_DENY; 2989 break; 2990 case AP_MAC_CMD_FLUSH: 2991 ap_control_flush_macs(&local->ap->mac_restrictions); 2992 break; 2993 case AP_MAC_CMD_KICKALL: 2994 ap_control_kickall(local->ap); 2995 hostap_deauth_all_stas(local->dev, local->ap, 0); 2996 break; 2997 default: 2998 ret = -EOPNOTSUPP; 2999 break; 3000 } 3001 3002 return ret; 3003} 3004#endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */ 3005 3006 3007#ifdef PRISM2_DOWNLOAD_SUPPORT 3008static int prism2_ioctl_priv_download(local_info_t *local, struct iw_point *p) 3009{ 3010 struct prism2_download_param *param; 3011 int ret = 0; 3012 3013 if (p->length < sizeof(struct prism2_download_param) || 3014 p->length > 1024 || !p->pointer) 3015 return -EINVAL; 3016 3017 param = kmalloc(p->length, GFP_KERNEL); 3018 if (param == NULL) 3019 return -ENOMEM; 3020 3021 if (copy_from_user(param, p->pointer, p->length)) { 3022 ret = -EFAULT; 3023 goto out; 3024 } 3025 3026 if (p->length < sizeof(struct prism2_download_param) + 3027 param->num_areas * sizeof(struct prism2_download_area)) { 3028 ret = -EINVAL; 3029 goto out; 3030 } 3031 3032 ret = local->func->download(local, param); 3033 3034 out: 3035 kfree(param); 3036 return ret; 3037} 3038#endif /* PRISM2_DOWNLOAD_SUPPORT */ 3039 3040 3041static int prism2_set_genericelement(struct net_device *dev, u8 *elem, 3042 size_t len) 3043{ 3044 struct hostap_interface *iface = netdev_priv(dev); 3045 local_info_t *local = iface->local; 3046 u8 *buf; 3047 3048 /* 3049 * Add 16-bit length in the beginning of the buffer because Prism2 RID 3050 * includes it. 3051 */ 3052 buf = kmalloc(len + 2, GFP_KERNEL); 3053 if (buf == NULL) 3054 return -ENOMEM; 3055 3056 *((__le16 *) buf) = cpu_to_le16(len); 3057 memcpy(buf + 2, elem, len); 3058 3059 kfree(local->generic_elem); 3060 local->generic_elem = buf; 3061 local->generic_elem_len = len + 2; 3062 3063 return local->func->set_rid(local->dev, HFA384X_RID_GENERICELEMENT, 3064 buf, len + 2); 3065} 3066 3067 3068static int prism2_ioctl_siwauth(struct net_device *dev, 3069 struct iw_request_info *info, 3070 struct iw_param *data, char *extra) 3071{ 3072 struct hostap_interface *iface = netdev_priv(dev); 3073 local_info_t *local = iface->local; 3074 3075 switch (data->flags & IW_AUTH_INDEX) { 3076 case IW_AUTH_WPA_VERSION: 3077 case IW_AUTH_CIPHER_PAIRWISE: 3078 case IW_AUTH_CIPHER_GROUP: 3079 case IW_AUTH_KEY_MGMT: 3080 /* 3081 * Host AP driver does not use these parameters and allows 3082 * wpa_supplicant to control them internally. 3083 */ 3084 break; 3085 case IW_AUTH_TKIP_COUNTERMEASURES: 3086 local->tkip_countermeasures = data->value; 3087 break; 3088 case IW_AUTH_DROP_UNENCRYPTED: 3089 local->drop_unencrypted = data->value; 3090 break; 3091 case IW_AUTH_80211_AUTH_ALG: 3092 local->auth_algs = data->value; 3093 break; 3094 case IW_AUTH_WPA_ENABLED: 3095 if (data->value == 0) { 3096 local->wpa = 0; 3097 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0)) 3098 break; 3099 prism2_set_genericelement(dev, "", 0); 3100 local->host_roaming = 0; 3101 local->privacy_invoked = 0; 3102 if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE, 3103 0) || 3104 hostap_set_roaming(local) || 3105 hostap_set_encryption(local) || 3106 local->func->reset_port(dev)) 3107 return -EINVAL; 3108 break; 3109 } 3110 if (local->sta_fw_ver < PRISM2_FW_VER(1,7,0)) 3111 return -EOPNOTSUPP; 3112 local->host_roaming = 2; 3113 local->privacy_invoked = 1; 3114 local->wpa = 1; 3115 if (hostap_set_word(dev, HFA384X_RID_SSNHANDLINGMODE, 1) || 3116 hostap_set_roaming(local) || 3117 hostap_set_encryption(local) || 3118 local->func->reset_port(dev)) 3119 return -EINVAL; 3120 break; 3121 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 3122 local->ieee_802_1x = data->value; 3123 break; 3124 case IW_AUTH_PRIVACY_INVOKED: 3125 local->privacy_invoked = data->value; 3126 break; 3127 default: 3128 return -EOPNOTSUPP; 3129 } 3130 return 0; 3131} 3132 3133 3134static int prism2_ioctl_giwauth(struct net_device *dev, 3135 struct iw_request_info *info, 3136 struct iw_param *data, char *extra) 3137{ 3138 struct hostap_interface *iface = netdev_priv(dev); 3139 local_info_t *local = iface->local; 3140 3141 switch (data->flags & IW_AUTH_INDEX) { 3142 case IW_AUTH_WPA_VERSION: 3143 case IW_AUTH_CIPHER_PAIRWISE: 3144 case IW_AUTH_CIPHER_GROUP: 3145 case IW_AUTH_KEY_MGMT: 3146 /* 3147 * Host AP driver does not use these parameters and allows 3148 * wpa_supplicant to control them internally. 3149 */ 3150 return -EOPNOTSUPP; 3151 case IW_AUTH_TKIP_COUNTERMEASURES: 3152 data->value = local->tkip_countermeasures; 3153 break; 3154 case IW_AUTH_DROP_UNENCRYPTED: 3155 data->value = local->drop_unencrypted; 3156 break; 3157 case IW_AUTH_80211_AUTH_ALG: 3158 data->value = local->auth_algs; 3159 break; 3160 case IW_AUTH_WPA_ENABLED: 3161 data->value = local->wpa; 3162 break; 3163 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 3164 data->value = local->ieee_802_1x; 3165 break; 3166 default: 3167 return -EOPNOTSUPP; 3168 } 3169 return 0; 3170} 3171 3172 3173static int prism2_ioctl_siwencodeext(struct net_device *dev, 3174 struct iw_request_info *info, 3175 struct iw_point *erq, char *extra) 3176{ 3177 struct hostap_interface *iface = netdev_priv(dev); 3178 local_info_t *local = iface->local; 3179 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra; 3180 int i, ret = 0; 3181 struct lib80211_crypto_ops *ops; 3182 struct lib80211_crypt_data **crypt; 3183 void *sta_ptr; 3184 u8 *addr; 3185 const char *alg, *module; 3186 3187 i = erq->flags & IW_ENCODE_INDEX; 3188 if (i > WEP_KEYS) 3189 return -EINVAL; 3190 if (i < 1 || i > WEP_KEYS) 3191 i = local->crypt_info.tx_keyidx; 3192 else 3193 i--; 3194 if (i < 0 || i >= WEP_KEYS) 3195 return -EINVAL; 3196 3197 addr = ext->addr.sa_data; 3198 if (addr[0] == 0xff && addr[1] == 0xff && addr[2] == 0xff && 3199 addr[3] == 0xff && addr[4] == 0xff && addr[5] == 0xff) { 3200 sta_ptr = NULL; 3201 crypt = &local->crypt_info.crypt[i]; 3202 } else { 3203 if (i != 0) 3204 return -EINVAL; 3205 sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt); 3206 if (sta_ptr == NULL) { 3207 if (local->iw_mode == IW_MODE_INFRA) { 3208 /* 3209 * TODO: add STA entry for the current AP so 3210 * that unicast key can be used. For now, this 3211 * is emulated by using default key idx 0. 3212 */ 3213 i = 0; 3214 crypt = &local->crypt_info.crypt[i]; 3215 } else 3216 return -EINVAL; 3217 } 3218 } 3219 3220 if ((erq->flags & IW_ENCODE_DISABLED) || 3221 ext->alg == IW_ENCODE_ALG_NONE) { 3222 if (*crypt) 3223 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt); 3224 goto done; 3225 } 3226 3227 switch (ext->alg) { 3228 case IW_ENCODE_ALG_WEP: 3229 alg = "WEP"; 3230 module = "lib80211_crypt_wep"; 3231 break; 3232 case IW_ENCODE_ALG_TKIP: 3233 alg = "TKIP"; 3234 module = "lib80211_crypt_tkip"; 3235 break; 3236 case IW_ENCODE_ALG_CCMP: 3237 alg = "CCMP"; 3238 module = "lib80211_crypt_ccmp"; 3239 break; 3240 default: 3241 printk(KERN_DEBUG "%s: unsupported algorithm %d\n", 3242 local->dev->name, ext->alg); 3243 ret = -EOPNOTSUPP; 3244 goto done; 3245 } 3246 3247 ops = lib80211_get_crypto_ops(alg); 3248 if (ops == NULL) { 3249 request_module(module); 3250 ops = lib80211_get_crypto_ops(alg); 3251 } 3252 if (ops == NULL) { 3253 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n", 3254 local->dev->name, alg); 3255 ret = -EOPNOTSUPP; 3256 goto done; 3257 } 3258 3259 if (sta_ptr || ext->alg != IW_ENCODE_ALG_WEP) { 3260 /* 3261 * Per station encryption and other than WEP algorithms 3262 * require host-based encryption, so force them on 3263 * automatically. 3264 */ 3265 local->host_decrypt = local->host_encrypt = 1; 3266 } 3267 3268 if (*crypt == NULL || (*crypt)->ops != ops) { 3269 struct lib80211_crypt_data *new_crypt; 3270 3271 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt); 3272 3273 new_crypt = kzalloc(sizeof(struct lib80211_crypt_data), 3274 GFP_KERNEL); 3275 if (new_crypt == NULL) { 3276 ret = -ENOMEM; 3277 goto done; 3278 } 3279 new_crypt->ops = ops; 3280 if (new_crypt->ops && try_module_get(new_crypt->ops->owner)) 3281 new_crypt->priv = new_crypt->ops->init(i); 3282 if (new_crypt->priv == NULL) { 3283 kfree(new_crypt); 3284 ret = -EINVAL; 3285 goto done; 3286 } 3287 3288 *crypt = new_crypt; 3289 } 3290 3291 /* 3292 * TODO: if ext_flags does not have IW_ENCODE_EXT_RX_SEQ_VALID, the 3293 * existing seq# should not be changed. 3294 * TODO: if ext_flags has IW_ENCODE_EXT_TX_SEQ_VALID, next TX seq# 3295 * should be changed to something else than zero. 3296 */ 3297 if ((!(ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) || ext->key_len > 0) 3298 && (*crypt)->ops->set_key && 3299 (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq, 3300 (*crypt)->priv) < 0) { 3301 printk(KERN_DEBUG "%s: key setting failed\n", 3302 local->dev->name); 3303 ret = -EINVAL; 3304 goto done; 3305 } 3306 3307 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) { 3308 if (!sta_ptr) 3309 local->crypt_info.tx_keyidx = i; 3310 } 3311 3312 3313 if (sta_ptr == NULL && ext->key_len > 0) { 3314 int first = 1, j; 3315 for (j = 0; j < WEP_KEYS; j++) { 3316 if (j != i && local->crypt_info.crypt[j]) { 3317 first = 0; 3318 break; 3319 } 3320 } 3321 if (first) 3322 local->crypt_info.tx_keyidx = i; 3323 } 3324 3325 done: 3326 if (sta_ptr) 3327 hostap_handle_sta_release(sta_ptr); 3328 3329 local->open_wep = erq->flags & IW_ENCODE_OPEN; 3330 3331 /* 3332 * Do not reset port0 if card is in Managed mode since resetting will 3333 * generate new IEEE 802.11 authentication which may end up in looping 3334 * with IEEE 802.1X. Prism2 documentation seem to require port reset 3335 * after WEP configuration. However, keys are apparently changed at 3336 * least in Managed mode. 3337 */ 3338 if (ret == 0 && 3339 (hostap_set_encryption(local) || 3340 (local->iw_mode != IW_MODE_INFRA && 3341 local->func->reset_port(local->dev)))) 3342 ret = -EINVAL; 3343 3344 return ret; 3345} 3346 3347 3348static int prism2_ioctl_giwencodeext(struct net_device *dev, 3349 struct iw_request_info *info, 3350 struct iw_point *erq, char *extra) 3351{ 3352 struct hostap_interface *iface = netdev_priv(dev); 3353 local_info_t *local = iface->local; 3354 struct lib80211_crypt_data **crypt; 3355 void *sta_ptr; 3356 int max_key_len, i; 3357 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra; 3358 u8 *addr; 3359 3360 max_key_len = erq->length - sizeof(*ext); 3361 if (max_key_len < 0) 3362 return -EINVAL; 3363 3364 i = erq->flags & IW_ENCODE_INDEX; 3365 if (i < 1 || i > WEP_KEYS) 3366 i = local->crypt_info.tx_keyidx; 3367 else 3368 i--; 3369 3370 addr = ext->addr.sa_data; 3371 if (addr[0] == 0xff && addr[1] == 0xff && addr[2] == 0xff && 3372 addr[3] == 0xff && addr[4] == 0xff && addr[5] == 0xff) { 3373 sta_ptr = NULL; 3374 crypt = &local->crypt_info.crypt[i]; 3375 } else { 3376 i = 0; 3377 sta_ptr = ap_crypt_get_ptrs(local->ap, addr, 0, &crypt); 3378 if (sta_ptr == NULL) 3379 return -EINVAL; 3380 } 3381 erq->flags = i + 1; 3382 memset(ext, 0, sizeof(*ext)); 3383 3384 if (*crypt == NULL || (*crypt)->ops == NULL) { 3385 ext->alg = IW_ENCODE_ALG_NONE; 3386 ext->key_len = 0; 3387 erq->flags |= IW_ENCODE_DISABLED; 3388 } else { 3389 if (strcmp((*crypt)->ops->name, "WEP") == 0) 3390 ext->alg = IW_ENCODE_ALG_WEP; 3391 else if (strcmp((*crypt)->ops->name, "TKIP") == 0) 3392 ext->alg = IW_ENCODE_ALG_TKIP; 3393 else if (strcmp((*crypt)->ops->name, "CCMP") == 0) 3394 ext->alg = IW_ENCODE_ALG_CCMP; 3395 else 3396 return -EINVAL; 3397 3398 if ((*crypt)->ops->get_key) { 3399 ext->key_len = 3400 (*crypt)->ops->get_key(ext->key, 3401 max_key_len, 3402 ext->tx_seq, 3403 (*crypt)->priv); 3404 if (ext->key_len && 3405 (ext->alg == IW_ENCODE_ALG_TKIP || 3406 ext->alg == IW_ENCODE_ALG_CCMP)) 3407 ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID; 3408 } 3409 } 3410 3411 if (sta_ptr) 3412 hostap_handle_sta_release(sta_ptr); 3413 3414 return 0; 3415} 3416 3417 3418static int prism2_ioctl_set_encryption(local_info_t *local, 3419 struct prism2_hostapd_param *param, 3420 int param_len) 3421{ 3422 int ret = 0; 3423 struct lib80211_crypto_ops *ops; 3424 struct lib80211_crypt_data **crypt; 3425 void *sta_ptr; 3426 3427 param->u.crypt.err = 0; 3428 param->u.crypt.alg[HOSTAP_CRYPT_ALG_NAME_LEN - 1] = '\0'; 3429 3430 if (param_len != 3431 (int) ((char *) param->u.crypt.key - (char *) param) + 3432 param->u.crypt.key_len) 3433 return -EINVAL; 3434 3435 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 3436 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 3437 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 3438 if (param->u.crypt.idx >= WEP_KEYS) 3439 return -EINVAL; 3440 sta_ptr = NULL; 3441 crypt = &local->crypt_info.crypt[param->u.crypt.idx]; 3442 } else { 3443 if (param->u.crypt.idx) 3444 return -EINVAL; 3445 sta_ptr = ap_crypt_get_ptrs( 3446 local->ap, param->sta_addr, 3447 (param->u.crypt.flags & HOSTAP_CRYPT_FLAG_PERMANENT), 3448 &crypt); 3449 3450 if (sta_ptr == NULL) { 3451 param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR; 3452 return -EINVAL; 3453 } 3454 } 3455 3456 if (strcmp(param->u.crypt.alg, "none") == 0) { 3457 if (crypt) 3458 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt); 3459 goto done; 3460 } 3461 3462 ops = lib80211_get_crypto_ops(param->u.crypt.alg); 3463 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) { 3464 request_module("lib80211_crypt_wep"); 3465 ops = lib80211_get_crypto_ops(param->u.crypt.alg); 3466 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) { 3467 request_module("lib80211_crypt_tkip"); 3468 ops = lib80211_get_crypto_ops(param->u.crypt.alg); 3469 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) { 3470 request_module("lib80211_crypt_ccmp"); 3471 ops = lib80211_get_crypto_ops(param->u.crypt.alg); 3472 } 3473 if (ops == NULL) { 3474 printk(KERN_DEBUG "%s: unknown crypto alg '%s'\n", 3475 local->dev->name, param->u.crypt.alg); 3476 param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ALG; 3477 ret = -EINVAL; 3478 goto done; 3479 } 3480 3481 /* station based encryption and other than WEP algorithms require 3482 * host-based encryption, so force them on automatically */ 3483 local->host_decrypt = local->host_encrypt = 1; 3484 3485 if (*crypt == NULL || (*crypt)->ops != ops) { 3486 struct lib80211_crypt_data *new_crypt; 3487 3488 lib80211_crypt_delayed_deinit(&local->crypt_info, crypt); 3489 3490 new_crypt = kzalloc(sizeof(struct lib80211_crypt_data), 3491 GFP_KERNEL); 3492 if (new_crypt == NULL) { 3493 ret = -ENOMEM; 3494 goto done; 3495 } 3496 new_crypt->ops = ops; 3497 new_crypt->priv = new_crypt->ops->init(param->u.crypt.idx); 3498 if (new_crypt->priv == NULL) { 3499 kfree(new_crypt); 3500 param->u.crypt.err = 3501 HOSTAP_CRYPT_ERR_CRYPT_INIT_FAILED; 3502 ret = -EINVAL; 3503 goto done; 3504 } 3505 3506 *crypt = new_crypt; 3507 } 3508 3509 if ((!(param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY) || 3510 param->u.crypt.key_len > 0) && (*crypt)->ops->set_key && 3511 (*crypt)->ops->set_key(param->u.crypt.key, 3512 param->u.crypt.key_len, param->u.crypt.seq, 3513 (*crypt)->priv) < 0) { 3514 printk(KERN_DEBUG "%s: key setting failed\n", 3515 local->dev->name); 3516 param->u.crypt.err = HOSTAP_CRYPT_ERR_KEY_SET_FAILED; 3517 ret = -EINVAL; 3518 goto done; 3519 } 3520 3521 if (param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY) { 3522 if (!sta_ptr) 3523 local->crypt_info.tx_keyidx = param->u.crypt.idx; 3524 else if (param->u.crypt.idx) { 3525 printk(KERN_DEBUG "%s: TX key idx setting failed\n", 3526 local->dev->name); 3527 param->u.crypt.err = 3528 HOSTAP_CRYPT_ERR_TX_KEY_SET_FAILED; 3529 ret = -EINVAL; 3530 goto done; 3531 } 3532 } 3533 3534 done: 3535 if (sta_ptr) 3536 hostap_handle_sta_release(sta_ptr); 3537 3538 /* Do not reset port0 if card is in Managed mode since resetting will 3539 * generate new IEEE 802.11 authentication which may end up in looping 3540 * with IEEE 802.1X. Prism2 documentation seem to require port reset 3541 * after WEP configuration. However, keys are apparently changed at 3542 * least in Managed mode. */ 3543 if (ret == 0 && 3544 (hostap_set_encryption(local) || 3545 (local->iw_mode != IW_MODE_INFRA && 3546 local->func->reset_port(local->dev)))) { 3547 param->u.crypt.err = HOSTAP_CRYPT_ERR_CARD_CONF_FAILED; 3548 return -EINVAL; 3549 } 3550 3551 return ret; 3552} 3553 3554 3555static int prism2_ioctl_get_encryption(local_info_t *local, 3556 struct prism2_hostapd_param *param, 3557 int param_len) 3558{ 3559 struct lib80211_crypt_data **crypt; 3560 void *sta_ptr; 3561 int max_key_len; 3562 3563 param->u.crypt.err = 0; 3564 3565 max_key_len = param_len - 3566 (int) ((char *) param->u.crypt.key - (char *) param); 3567 if (max_key_len < 0) 3568 return -EINVAL; 3569 3570 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 3571 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 3572 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 3573 sta_ptr = NULL; 3574 if (param->u.crypt.idx >= WEP_KEYS) 3575 param->u.crypt.idx = local->crypt_info.tx_keyidx; 3576 crypt = &local->crypt_info.crypt[param->u.crypt.idx]; 3577 } else { 3578 param->u.crypt.idx = 0; 3579 sta_ptr = ap_crypt_get_ptrs(local->ap, param->sta_addr, 0, 3580 &crypt); 3581 3582 if (sta_ptr == NULL) { 3583 param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR; 3584 return -EINVAL; 3585 } 3586 } 3587 3588 if (*crypt == NULL || (*crypt)->ops == NULL) { 3589 memcpy(param->u.crypt.alg, "none", 5); 3590 param->u.crypt.key_len = 0; 3591 param->u.crypt.idx = 0xff; 3592 } else { 3593 strncpy(param->u.crypt.alg, (*crypt)->ops->name, 3594 HOSTAP_CRYPT_ALG_NAME_LEN); 3595 param->u.crypt.key_len = 0; 3596 3597 memset(param->u.crypt.seq, 0, 8); 3598 if ((*crypt)->ops->get_key) { 3599 param->u.crypt.key_len = 3600 (*crypt)->ops->get_key(param->u.crypt.key, 3601 max_key_len, 3602 param->u.crypt.seq, 3603 (*crypt)->priv); 3604 } 3605 } 3606 3607 if (sta_ptr) 3608 hostap_handle_sta_release(sta_ptr); 3609 3610 return 0; 3611} 3612 3613 3614static int prism2_ioctl_get_rid(local_info_t *local, 3615 struct prism2_hostapd_param *param, 3616 int param_len) 3617{ 3618 int max_len, res; 3619 3620 max_len = param_len - PRISM2_HOSTAPD_RID_HDR_LEN; 3621 if (max_len < 0) 3622 return -EINVAL; 3623 3624 res = local->func->get_rid(local->dev, param->u.rid.rid, 3625 param->u.rid.data, param->u.rid.len, 0); 3626 if (res >= 0) { 3627 param->u.rid.len = res; 3628 return 0; 3629 } 3630 3631 return res; 3632} 3633 3634 3635static int prism2_ioctl_set_rid(local_info_t *local, 3636 struct prism2_hostapd_param *param, 3637 int param_len) 3638{ 3639 int max_len; 3640 3641 max_len = param_len - PRISM2_HOSTAPD_RID_HDR_LEN; 3642 if (max_len < 0 || max_len < param->u.rid.len) 3643 return -EINVAL; 3644 3645 return local->func->set_rid(local->dev, param->u.rid.rid, 3646 param->u.rid.data, param->u.rid.len); 3647} 3648 3649 3650static int prism2_ioctl_set_assoc_ap_addr(local_info_t *local, 3651 struct prism2_hostapd_param *param, 3652 int param_len) 3653{ 3654 printk(KERN_DEBUG "%ssta: associated as client with AP %pM\n", 3655 local->dev->name, param->sta_addr); 3656 memcpy(local->assoc_ap_addr, param->sta_addr, ETH_ALEN); 3657 return 0; 3658} 3659 3660 3661static int prism2_ioctl_siwgenie(struct net_device *dev, 3662 struct iw_request_info *info, 3663 struct iw_point *data, char *extra) 3664{ 3665 return prism2_set_genericelement(dev, extra, data->length); 3666} 3667 3668 3669static int prism2_ioctl_giwgenie(struct net_device *dev, 3670 struct iw_request_info *info, 3671 struct iw_point *data, char *extra) 3672{ 3673 struct hostap_interface *iface = netdev_priv(dev); 3674 local_info_t *local = iface->local; 3675 int len = local->generic_elem_len - 2; 3676 3677 if (len <= 0 || local->generic_elem == NULL) { 3678 data->length = 0; 3679 return 0; 3680 } 3681 3682 if (data->length < len) 3683 return -E2BIG; 3684 3685 data->length = len; 3686 memcpy(extra, local->generic_elem + 2, len); 3687 3688 return 0; 3689} 3690 3691 3692static int prism2_ioctl_set_generic_element(local_info_t *local, 3693 struct prism2_hostapd_param *param, 3694 int param_len) 3695{ 3696 int max_len, len; 3697 3698 len = param->u.generic_elem.len; 3699 max_len = param_len - PRISM2_HOSTAPD_GENERIC_ELEMENT_HDR_LEN; 3700 if (max_len < 0 || max_len < len) 3701 return -EINVAL; 3702 3703 return prism2_set_genericelement(local->dev, 3704 param->u.generic_elem.data, len); 3705} 3706 3707 3708static int prism2_ioctl_siwmlme(struct net_device *dev, 3709 struct iw_request_info *info, 3710 struct iw_point *data, char *extra) 3711{ 3712 struct hostap_interface *iface = netdev_priv(dev); 3713 local_info_t *local = iface->local; 3714 struct iw_mlme *mlme = (struct iw_mlme *) extra; 3715 __le16 reason; 3716 3717 reason = cpu_to_le16(mlme->reason_code); 3718 3719 switch (mlme->cmd) { 3720 case IW_MLME_DEAUTH: 3721 return prism2_sta_send_mgmt(local, mlme->addr.sa_data, 3722 IEEE80211_STYPE_DEAUTH, 3723 (u8 *) &reason, 2); 3724 case IW_MLME_DISASSOC: 3725 return prism2_sta_send_mgmt(local, mlme->addr.sa_data, 3726 IEEE80211_STYPE_DISASSOC, 3727 (u8 *) &reason, 2); 3728 default: 3729 return -EOPNOTSUPP; 3730 } 3731} 3732 3733 3734static int prism2_ioctl_mlme(local_info_t *local, 3735 struct prism2_hostapd_param *param) 3736{ 3737 __le16 reason; 3738 3739 reason = cpu_to_le16(param->u.mlme.reason_code); 3740 switch (param->u.mlme.cmd) { 3741 case MLME_STA_DEAUTH: 3742 return prism2_sta_send_mgmt(local, param->sta_addr, 3743 IEEE80211_STYPE_DEAUTH, 3744 (u8 *) &reason, 2); 3745 case MLME_STA_DISASSOC: 3746 return prism2_sta_send_mgmt(local, param->sta_addr, 3747 IEEE80211_STYPE_DISASSOC, 3748 (u8 *) &reason, 2); 3749 default: 3750 return -EOPNOTSUPP; 3751 } 3752} 3753 3754 3755static int prism2_ioctl_scan_req(local_info_t *local, 3756 struct prism2_hostapd_param *param) 3757{ 3758#ifndef PRISM2_NO_STATION_MODES 3759 if ((local->iw_mode != IW_MODE_INFRA && 3760 local->iw_mode != IW_MODE_ADHOC) || 3761 (local->sta_fw_ver < PRISM2_FW_VER(1,3,1))) 3762 return -EOPNOTSUPP; 3763 3764 if (!local->dev_enabled) 3765 return -ENETDOWN; 3766 3767 return prism2_request_hostscan(local->dev, param->u.scan_req.ssid, 3768 param->u.scan_req.ssid_len); 3769#else /* PRISM2_NO_STATION_MODES */ 3770 return -EOPNOTSUPP; 3771#endif /* PRISM2_NO_STATION_MODES */ 3772} 3773 3774 3775static int prism2_ioctl_priv_hostapd(local_info_t *local, struct iw_point *p) 3776{ 3777 struct prism2_hostapd_param *param; 3778 int ret = 0; 3779 int ap_ioctl = 0; 3780 3781 if (p->length < sizeof(struct prism2_hostapd_param) || 3782 p->length > PRISM2_HOSTAPD_MAX_BUF_SIZE || !p->pointer) 3783 return -EINVAL; 3784 3785 param = kmalloc(p->length, GFP_KERNEL); 3786 if (param == NULL) 3787 return -ENOMEM; 3788 3789 if (copy_from_user(param, p->pointer, p->length)) { 3790 ret = -EFAULT; 3791 goto out; 3792 } 3793 3794 switch (param->cmd) { 3795 case PRISM2_SET_ENCRYPTION: 3796 ret = prism2_ioctl_set_encryption(local, param, p->length); 3797 break; 3798 case PRISM2_GET_ENCRYPTION: 3799 ret = prism2_ioctl_get_encryption(local, param, p->length); 3800 break; 3801 case PRISM2_HOSTAPD_GET_RID: 3802 ret = prism2_ioctl_get_rid(local, param, p->length); 3803 break; 3804 case PRISM2_HOSTAPD_SET_RID: 3805 ret = prism2_ioctl_set_rid(local, param, p->length); 3806 break; 3807 case PRISM2_HOSTAPD_SET_ASSOC_AP_ADDR: 3808 ret = prism2_ioctl_set_assoc_ap_addr(local, param, p->length); 3809 break; 3810 case PRISM2_HOSTAPD_SET_GENERIC_ELEMENT: 3811 ret = prism2_ioctl_set_generic_element(local, param, 3812 p->length); 3813 break; 3814 case PRISM2_HOSTAPD_MLME: 3815 ret = prism2_ioctl_mlme(local, param); 3816 break; 3817 case PRISM2_HOSTAPD_SCAN_REQ: 3818 ret = prism2_ioctl_scan_req(local, param); 3819 break; 3820 default: 3821 ret = prism2_hostapd(local->ap, param); 3822 ap_ioctl = 1; 3823 break; 3824 } 3825 3826 if (ret == 1 || !ap_ioctl) { 3827 if (copy_to_user(p->pointer, param, p->length)) { 3828 ret = -EFAULT; 3829 goto out; 3830 } else if (ap_ioctl) 3831 ret = 0; 3832 } 3833 3834 out: 3835 kfree(param); 3836 return ret; 3837} 3838 3839 3840static void prism2_get_drvinfo(struct net_device *dev, 3841 struct ethtool_drvinfo *info) 3842{ 3843 struct hostap_interface *iface; 3844 local_info_t *local; 3845 3846 iface = netdev_priv(dev); 3847 local = iface->local; 3848 3849 strncpy(info->driver, "hostap", sizeof(info->driver) - 1); 3850 snprintf(info->fw_version, sizeof(info->fw_version) - 1, 3851 "%d.%d.%d", (local->sta_fw_ver >> 16) & 0xff, 3852 (local->sta_fw_ver >> 8) & 0xff, 3853 local->sta_fw_ver & 0xff); 3854} 3855 3856const struct ethtool_ops prism2_ethtool_ops = { 3857 .get_drvinfo = prism2_get_drvinfo 3858}; 3859 3860 3861/* Structures to export the Wireless Handlers */ 3862 3863static const iw_handler prism2_handler[] = 3864{ 3865 (iw_handler) NULL, /* SIOCSIWCOMMIT */ 3866 (iw_handler) prism2_get_name, /* SIOCGIWNAME */ 3867 (iw_handler) NULL, /* SIOCSIWNWID */ 3868 (iw_handler) NULL, /* SIOCGIWNWID */ 3869 (iw_handler) prism2_ioctl_siwfreq, /* SIOCSIWFREQ */ 3870 (iw_handler) prism2_ioctl_giwfreq, /* SIOCGIWFREQ */ 3871 (iw_handler) prism2_ioctl_siwmode, /* SIOCSIWMODE */ 3872 (iw_handler) prism2_ioctl_giwmode, /* SIOCGIWMODE */ 3873 (iw_handler) prism2_ioctl_siwsens, /* SIOCSIWSENS */ 3874 (iw_handler) prism2_ioctl_giwsens, /* SIOCGIWSENS */ 3875 (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */ 3876 (iw_handler) prism2_ioctl_giwrange, /* SIOCGIWRANGE */ 3877 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */ 3878 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */ 3879 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */ 3880 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */ 3881 iw_handler_set_spy, /* SIOCSIWSPY */ 3882 iw_handler_get_spy, /* SIOCGIWSPY */ 3883 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */ 3884 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */ 3885 (iw_handler) prism2_ioctl_siwap, /* SIOCSIWAP */ 3886 (iw_handler) prism2_ioctl_giwap, /* SIOCGIWAP */ 3887 (iw_handler) prism2_ioctl_siwmlme, /* SIOCSIWMLME */ 3888 (iw_handler) prism2_ioctl_giwaplist, /* SIOCGIWAPLIST */ 3889 (iw_handler) prism2_ioctl_siwscan, /* SIOCSIWSCAN */ 3890 (iw_handler) prism2_ioctl_giwscan, /* SIOCGIWSCAN */ 3891 (iw_handler) prism2_ioctl_siwessid, /* SIOCSIWESSID */ 3892 (iw_handler) prism2_ioctl_giwessid, /* SIOCGIWESSID */ 3893 (iw_handler) prism2_ioctl_siwnickn, /* SIOCSIWNICKN */ 3894 (iw_handler) prism2_ioctl_giwnickn, /* SIOCGIWNICKN */ 3895 (iw_handler) NULL, /* -- hole -- */ 3896 (iw_handler) NULL, /* -- hole -- */ 3897 (iw_handler) prism2_ioctl_siwrate, /* SIOCSIWRATE */ 3898 (iw_handler) prism2_ioctl_giwrate, /* SIOCGIWRATE */ 3899 (iw_handler) prism2_ioctl_siwrts, /* SIOCSIWRTS */ 3900 (iw_handler) prism2_ioctl_giwrts, /* SIOCGIWRTS */ 3901 (iw_handler) prism2_ioctl_siwfrag, /* SIOCSIWFRAG */ 3902 (iw_handler) prism2_ioctl_giwfrag, /* SIOCGIWFRAG */ 3903 (iw_handler) prism2_ioctl_siwtxpow, /* SIOCSIWTXPOW */ 3904 (iw_handler) prism2_ioctl_giwtxpow, /* SIOCGIWTXPOW */ 3905 (iw_handler) prism2_ioctl_siwretry, /* SIOCSIWRETRY */ 3906 (iw_handler) prism2_ioctl_giwretry, /* SIOCGIWRETRY */ 3907 (iw_handler) prism2_ioctl_siwencode, /* SIOCSIWENCODE */ 3908 (iw_handler) prism2_ioctl_giwencode, /* SIOCGIWENCODE */ 3909 (iw_handler) prism2_ioctl_siwpower, /* SIOCSIWPOWER */ 3910 (iw_handler) prism2_ioctl_giwpower, /* SIOCGIWPOWER */ 3911 (iw_handler) NULL, /* -- hole -- */ 3912 (iw_handler) NULL, /* -- hole -- */ 3913 (iw_handler) prism2_ioctl_siwgenie, /* SIOCSIWGENIE */ 3914 (iw_handler) prism2_ioctl_giwgenie, /* SIOCGIWGENIE */ 3915 (iw_handler) prism2_ioctl_siwauth, /* SIOCSIWAUTH */ 3916 (iw_handler) prism2_ioctl_giwauth, /* SIOCGIWAUTH */ 3917 (iw_handler) prism2_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */ 3918 (iw_handler) prism2_ioctl_giwencodeext, /* SIOCGIWENCODEEXT */ 3919 (iw_handler) NULL, /* SIOCSIWPMKSA */ 3920 (iw_handler) NULL, /* -- hole -- */ 3921}; 3922 3923static const iw_handler prism2_private_handler[] = 3924{ /* SIOCIWFIRSTPRIV + */ 3925 (iw_handler) prism2_ioctl_priv_prism2_param, /* 0 */ 3926 (iw_handler) prism2_ioctl_priv_get_prism2_param, /* 1 */ 3927 (iw_handler) prism2_ioctl_priv_writemif, /* 2 */ 3928 (iw_handler) prism2_ioctl_priv_readmif, /* 3 */ 3929}; 3930 3931const struct iw_handler_def hostap_iw_handler_def = 3932{ 3933 .num_standard = ARRAY_SIZE(prism2_handler), 3934 .num_private = ARRAY_SIZE(prism2_private_handler), 3935 .num_private_args = ARRAY_SIZE(prism2_priv), 3936 .standard = (iw_handler *) prism2_handler, 3937 .private = (iw_handler *) prism2_private_handler, 3938 .private_args = (struct iw_priv_args *) prism2_priv, 3939 .get_wireless_stats = hostap_get_wireless_stats, 3940}; 3941 3942 3943int hostap_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 3944{ 3945 struct iwreq *wrq = (struct iwreq *) ifr; 3946 struct hostap_interface *iface; 3947 local_info_t *local; 3948 int ret = 0; 3949 3950 iface = netdev_priv(dev); 3951 local = iface->local; 3952 3953 switch (cmd) { 3954 /* Private ioctls (iwpriv) that have not yet been converted 3955 * into new wireless extensions API */ 3956 3957 case PRISM2_IOCTL_INQUIRE: 3958 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3959 else ret = prism2_ioctl_priv_inquire(dev, (int *) wrq->u.name); 3960 break; 3961 3962 case PRISM2_IOCTL_MONITOR: 3963 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3964 else ret = prism2_ioctl_priv_monitor(dev, (int *) wrq->u.name); 3965 break; 3966 3967 case PRISM2_IOCTL_RESET: 3968 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3969 else ret = prism2_ioctl_priv_reset(dev, (int *) wrq->u.name); 3970 break; 3971 3972 case PRISM2_IOCTL_WDS_ADD: 3973 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3974 else ret = prism2_wds_add(local, wrq->u.ap_addr.sa_data, 1); 3975 break; 3976 3977 case PRISM2_IOCTL_WDS_DEL: 3978 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3979 else ret = prism2_wds_del(local, wrq->u.ap_addr.sa_data, 1, 0); 3980 break; 3981 3982 case PRISM2_IOCTL_SET_RID_WORD: 3983 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3984 else ret = prism2_ioctl_priv_set_rid_word(dev, 3985 (int *) wrq->u.name); 3986 break; 3987 3988#ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT 3989 case PRISM2_IOCTL_MACCMD: 3990 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3991 else ret = ap_mac_cmd_ioctl(local, (int *) wrq->u.name); 3992 break; 3993 3994 case PRISM2_IOCTL_ADDMAC: 3995 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 3996 else ret = ap_control_add_mac(&local->ap->mac_restrictions, 3997 wrq->u.ap_addr.sa_data); 3998 break; 3999 case PRISM2_IOCTL_DELMAC: 4000 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 4001 else ret = ap_control_del_mac(&local->ap->mac_restrictions, 4002 wrq->u.ap_addr.sa_data); 4003 break; 4004 case PRISM2_IOCTL_KICKMAC: 4005 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 4006 else ret = ap_control_kick_mac(local->ap, local->dev, 4007 wrq->u.ap_addr.sa_data); 4008 break; 4009#endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */ 4010 4011 4012 /* Private ioctls that are not used with iwpriv; 4013 * in SIOCDEVPRIVATE range */ 4014 4015#ifdef PRISM2_DOWNLOAD_SUPPORT 4016 case PRISM2_IOCTL_DOWNLOAD: 4017 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 4018 else ret = prism2_ioctl_priv_download(local, &wrq->u.data); 4019 break; 4020#endif /* PRISM2_DOWNLOAD_SUPPORT */ 4021 4022 case PRISM2_IOCTL_HOSTAPD: 4023 if (!capable(CAP_NET_ADMIN)) ret = -EPERM; 4024 else ret = prism2_ioctl_priv_hostapd(local, &wrq->u.data); 4025 break; 4026 4027 default: 4028 ret = -EOPNOTSUPP; 4029 break; 4030 } 4031 4032 return ret; 4033} 4034