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