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