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