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