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