[deliverable/linux.git] / net / ieee80211 / softmac / ieee80211softmac_wx.c

/*
 * This file contains our _wx handlers. Make sure you EXPORT_SYMBOL_GPL them
 *
 * Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net>
 *                          Joseph Jezak <josejx@gentoo.org>
 *                          Larry Finger <Larry.Finger@lwfinger.net>
 *                          Danny van Dyk <kugelfang@gentoo.org>
 *                          Michael Buesch <mbuesch@freenet.de>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called COPYING.
 */

#include "ieee80211softmac_priv.h"

#include <net/iw_handler.h>
/* for is_broadcast_ether_addr and is_zero_ether_addr */
#include <linux/etherdevice.h>

int
ieee80211softmac_wx_trigger_scan(struct net_device *net_dev,
				 struct iw_request_info *info,
				 union iwreq_data *data,
				 char *extra)
{
	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);
	return ieee80211softmac_start_scan(sm);
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_trigger_scan);


/* if we're still scanning, return -EAGAIN so that userspace tools
 * can get the complete scan results, otherwise return 0. */
int
ieee80211softmac_wx_get_scan_results(struct net_device *net_dev,
				     struct iw_request_info *info,
				     union iwreq_data *data,
				     char *extra)
{
	unsigned long flags;
	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);

	spin_lock_irqsave(&sm->lock, flags);
	if (sm->scanning) {
		spin_unlock_irqrestore(&sm->lock, flags);
		return -EAGAIN;
	}
	spin_unlock_irqrestore(&sm->lock, flags);
	return ieee80211_wx_get_scan(sm->ieee, info, data, extra);
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_scan_results);

int
ieee80211softmac_wx_set_essid(struct net_device *net_dev,
			      struct iw_request_info *info,
			      union iwreq_data *data,
			      char *extra)
{
	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);
	struct ieee80211softmac_network *n;
	struct ieee80211softmac_auth_queue_item *authptr;
	int length = 0;

	mutex_lock(&sm->associnfo.mutex);

	/* Check if we're already associating to this or another network
	 * If it's another network, cancel and start over with our new network
	 * If it's our network, ignore the change, we're already doing it!
	 */
	if((sm->associnfo.associating || sm->associnfo.associated) &&
	   (data->essid.flags && data->essid.length)) {
		/* Get the associating network */
		n = ieee80211softmac_get_network_by_bssid(sm, sm->associnfo.bssid);
		if(n && n->essid.len == data->essid.length &&
		   !memcmp(n->essid.data, extra, n->essid.len)) {
			dprintk(KERN_INFO PFX "Already associating or associated to "MAC_FMT"\n",
				MAC_ARG(sm->associnfo.bssid));
			goto out;
		} else {
			dprintk(KERN_INFO PFX "Canceling existing associate request!\n");
			/* Cancel assoc work */
			cancel_delayed_work(&sm->associnfo.work);
			/* We don't have to do this, but it's a little cleaner */
			list_for_each_entry(authptr, &sm->auth_queue, list)
				cancel_delayed_work(&authptr->work);
			sm->associnfo.bssvalid = 0;
			sm->associnfo.bssfixed = 0;
			flush_scheduled_work();
			sm->associnfo.associating = 0;
			sm->associnfo.associated = 0;
		}
	}


	sm->associnfo.static_essid = 0;
	sm->associnfo.assoc_wait = 0;

	if (data->essid.flags && data->essid.length) {
		length = min((int)data->essid.length, IW_ESSID_MAX_SIZE);
		if (length) {
			memcpy(sm->associnfo.req_essid.data, extra, length);
			sm->associnfo.static_essid = 1;
		}
	}

	/* set our requested ESSID length.
	 * If applicable, we have already copied the data in */
	sm->associnfo.req_essid.len = length;

	sm->associnfo.associating = 1;
	/* queue lower level code to do work (if necessary) */
	schedule_delayed_work(&sm->associnfo.work, 0);
out:
	mutex_unlock(&sm->associnfo.mutex);

	return 0;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_essid);

int
ieee80211softmac_wx_get_essid(struct net_device *net_dev,
			      struct iw_request_info *info,
			      union iwreq_data *data,
			      char *extra)
{
	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);

	mutex_lock(&sm->associnfo.mutex);
	/* If all fails, return ANY (empty) */
	data->essid.length = 0;
	data->essid.flags = 0;  /* active */

	/* If we have a statically configured ESSID then return it */
	if (sm->associnfo.static_essid) {
		data->essid.length = sm->associnfo.req_essid.len;
		data->essid.flags = 1;  /* active */
		memcpy(extra, sm->associnfo.req_essid.data, sm->associnfo.req_essid.len);
	}

	/* If we're associating/associated, return that */
	if (sm->associnfo.associated || sm->associnfo.associating) {
		data->essid.length = sm->associnfo.associate_essid.len;
		data->essid.flags = 1;  /* active */
		memcpy(extra, sm->associnfo.associate_essid.data, sm->associnfo.associate_essid.len);
	}
	mutex_unlock(&sm->associnfo.mutex);

	return 0;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_essid);

int
ieee80211softmac_wx_set_rate(struct net_device *net_dev,
			     struct iw_request_info *info,
			     union iwreq_data *data,
			     char *extra)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
	struct ieee80211_device *ieee = mac->ieee;
	unsigned long flags;
	s32 in_rate = data->bitrate.value;
	u8 rate;
	int is_ofdm = 0;
	int err = -EINVAL;

	if (in_rate == -1) {
		/* FIXME: We don't correctly handle backing down to lower
		   rates, so 801.11g devices start off at 11M for now. People
		   can manually change it if they really need to, but 11M is
		   more reliable. Note similar logic in
		   ieee80211softmac_wx_set_rate() */
		if (ieee->modulation & IEEE80211_CCK_MODULATION)
			in_rate = 11000000;
		else
			in_rate = 54000000;
	}

	switch (in_rate) {
	case 1000000:
		rate = IEEE80211_CCK_RATE_1MB;
		break;
	case 2000000:
		rate = IEEE80211_CCK_RATE_2MB;
		break;
	case 5500000:
		rate = IEEE80211_CCK_RATE_5MB;
		break;
	case 11000000:
		rate = IEEE80211_CCK_RATE_11MB;
		break;
	case 6000000:
		rate = IEEE80211_OFDM_RATE_6MB;
		is_ofdm = 1;
		break;
	case 9000000:
		rate = IEEE80211_OFDM_RATE_9MB;
		is_ofdm = 1;
		break;
	case 12000000:
		rate = IEEE80211_OFDM_RATE_12MB;
		is_ofdm = 1;
		break;
	case 18000000:
		rate = IEEE80211_OFDM_RATE_18MB;
		is_ofdm = 1;
		break;
	case 24000000:
		rate = IEEE80211_OFDM_RATE_24MB;
		is_ofdm = 1;
		break;
	case 36000000:
		rate = IEEE80211_OFDM_RATE_36MB;
		is_ofdm = 1;
		break;
	case 48000000:
		rate = IEEE80211_OFDM_RATE_48MB;
		is_ofdm = 1;
		break;
	case 54000000:
		rate = IEEE80211_OFDM_RATE_54MB;
		is_ofdm = 1;
		break;
	default:
		goto out;
	}

	spin_lock_irqsave(&mac->lock, flags);

	/* Check if correct modulation for this PHY. */
	if (is_ofdm && !(ieee->modulation & IEEE80211_OFDM_MODULATION))
		goto out_unlock;

	mac->txrates.user_rate = rate;
	ieee80211softmac_recalc_txrates(mac);
	err = 0;

out_unlock:
	spin_unlock_irqrestore(&mac->lock, flags);
out:
	return err;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_rate);

int
ieee80211softmac_wx_get_rate(struct net_device *net_dev,
			     struct iw_request_info *info,
			     union iwreq_data *data,
			     char *extra)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
	unsigned long flags;
	int err = -EINVAL;

	spin_lock_irqsave(&mac->lock, flags);

	if (unlikely(!mac->running)) {
		err = -ENODEV;
		goto out_unlock;
	}

	switch (mac->txrates.default_rate) {
	case IEEE80211_CCK_RATE_1MB:
		data->bitrate.value = 1000000;
		break;
	case IEEE80211_CCK_RATE_2MB:
		data->bitrate.value = 2000000;
		break;
	case IEEE80211_CCK_RATE_5MB:
		data->bitrate.value = 5500000;
		break;
	case IEEE80211_CCK_RATE_11MB:
		data->bitrate.value = 11000000;
		break;
	case IEEE80211_OFDM_RATE_6MB:
		data->bitrate.value = 6000000;
		break;
	case IEEE80211_OFDM_RATE_9MB:
		data->bitrate.value = 9000000;
		break;
	case IEEE80211_OFDM_RATE_12MB:
		data->bitrate.value = 12000000;
		break;
	case IEEE80211_OFDM_RATE_18MB:
		data->bitrate.value = 18000000;
		break;
	case IEEE80211_OFDM_RATE_24MB:
		data->bitrate.value = 24000000;
		break;
	case IEEE80211_OFDM_RATE_36MB:
		data->bitrate.value = 36000000;
		break;
	case IEEE80211_OFDM_RATE_48MB:
		data->bitrate.value = 48000000;
		break;
	case IEEE80211_OFDM_RATE_54MB:
		data->bitrate.value = 54000000;
		break;
	default:
		assert(0);
		goto out_unlock;
	}
	err = 0;
out_unlock:
	spin_unlock_irqrestore(&mac->lock, flags);

	return err;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_rate);

int
ieee80211softmac_wx_get_wap(struct net_device *net_dev,
			    struct iw_request_info *info,
			    union iwreq_data *data,
			    char *extra)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
	int err = 0;

	mutex_lock(&mac->associnfo.mutex);
	if (mac->associnfo.bssvalid)
		memcpy(data->ap_addr.sa_data, mac->associnfo.bssid, ETH_ALEN);
	else
		memset(data->ap_addr.sa_data, 0xff, ETH_ALEN);
	data->ap_addr.sa_family = ARPHRD_ETHER;
	mutex_unlock(&mac->associnfo.mutex);

	return err;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_wap);

int
ieee80211softmac_wx_set_wap(struct net_device *net_dev,
			    struct iw_request_info *info,
			    union iwreq_data *data,
			    char *extra)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);

	/* sanity check */
	if (data->ap_addr.sa_family != ARPHRD_ETHER) {
		return -EINVAL;
	}

	mutex_lock(&mac->associnfo.mutex);
	if (is_broadcast_ether_addr(data->ap_addr.sa_data)) {
		/* the bssid we have is not to be fixed any longer,
		 * and we should reassociate to the best AP. */
		mac->associnfo.bssfixed = 0;
		/* force reassociation */
		mac->associnfo.bssvalid = 0;
		if (mac->associnfo.associated)
			schedule_delayed_work(&mac->associnfo.work, 0);
	} else if (is_zero_ether_addr(data->ap_addr.sa_data)) {
		/* the bssid we have is no longer fixed */
		mac->associnfo.bssfixed = 0;
	} else {
		if (!memcmp(mac->associnfo.bssid, data->ap_addr.sa_data, ETH_ALEN)) {
			if (mac->associnfo.associating || mac->associnfo.associated) {
			/* bssid unchanged and associated or associating - just return */
				goto out;
			}
		} else {
			/* copy new value in data->ap_addr.sa_data to bssid */
			memcpy(mac->associnfo.bssid, data->ap_addr.sa_data, ETH_ALEN);
		}
		/* tell the other code that this bssid should be used no matter what */
		mac->associnfo.bssfixed = 1;
		/* queue associate if new bssid or (old one again and not associated) */
		schedule_delayed_work(&mac->associnfo.work, 0);
	}

 out:
	mutex_unlock(&mac->associnfo.mutex);

	return 0;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_wap);

int
ieee80211softmac_wx_set_genie(struct net_device *dev,
			      struct iw_request_info *info,
			      union iwreq_data *wrqu,
			      char *extra)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	unsigned long flags;
	int err = 0;
	char *buf;
	int i;

	mutex_lock(&mac->associnfo.mutex);
	spin_lock_irqsave(&mac->lock, flags);
	/* bleh. shouldn't be locked for that kmalloc... */

	if (wrqu->data.length) {
		if ((wrqu->data.length < 2) || (extra[1]+2 != wrqu->data.length)) {
			/* this is an IE, so the length must be
			 * correct. Is it possible though that
			 * more than one IE is passed in?
			 */
			err = -EINVAL;
			goto out;
		}
		if (mac->wpa.IEbuflen <= wrqu->data.length) {
			buf = kmalloc(wrqu->data.length, GFP_ATOMIC);
			if (!buf) {
				err = -ENOMEM;
				goto out;
			}
			kfree(mac->wpa.IE);
			mac->wpa.IE = buf;
			mac->wpa.IEbuflen = wrqu->data.length;
		}
		memcpy(mac->wpa.IE, extra, wrqu->data.length);
		dprintk(KERN_INFO PFX "generic IE set to ");
		for (i=0;i<wrqu->data.length;i++)
			dprintk("%.2x", (u8)mac->wpa.IE[i]);
		dprintk("\n");
		mac->wpa.IElen = wrqu->data.length;
	} else {
		kfree(mac->wpa.IE);
		mac->wpa.IE = NULL;
		mac->wpa.IElen = 0;
		mac->wpa.IEbuflen = 0;
	}

 out:
	spin_unlock_irqrestore(&mac->lock, flags);
	mutex_unlock(&mac->associnfo.mutex);

	return err;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_genie);

int
ieee80211softmac_wx_get_genie(struct net_device *dev,
			      struct iw_request_info *info,
			      union iwreq_data *wrqu,
			      char *extra)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	unsigned long flags;
	int err = 0;
	int space = wrqu->data.length;

	mutex_lock(&mac->associnfo.mutex);
	spin_lock_irqsave(&mac->lock, flags);

	wrqu->data.length = 0;

	if (mac->wpa.IE && mac->wpa.IElen) {
		wrqu->data.length = mac->wpa.IElen;
		if (mac->wpa.IElen <= space)
			memcpy(extra, mac->wpa.IE, mac->wpa.IElen);
		else
			err = -E2BIG;
	}
	spin_unlock_irqrestore(&mac->lock, flags);
	mutex_unlock(&mac->associnfo.mutex);

	return err;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_genie);

int
ieee80211softmac_wx_set_mlme(struct net_device *dev,
			     struct iw_request_info *info,
			     union iwreq_data *wrqu,
			     char *extra)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	struct iw_mlme *mlme = (struct iw_mlme *)extra;
	u16 reason = cpu_to_le16(mlme->reason_code);
	struct ieee80211softmac_network *net;
	int err = -EINVAL;

	mutex_lock(&mac->associnfo.mutex);

	if (memcmp(mac->associnfo.bssid, mlme->addr.sa_data, ETH_ALEN)) {
		printk(KERN_DEBUG PFX "wx_set_mlme: requested operation on net we don't use\n");
		goto out;
	}

	switch (mlme->cmd) {
	case IW_MLME_DEAUTH:
		net = ieee80211softmac_get_network_by_bssid_locked(mac, mlme->addr.sa_data);
		if (!net) {
			printk(KERN_DEBUG PFX "wx_set_mlme: we should know the net here...\n");
			goto out;
		}
		err =  ieee80211softmac_deauth_req(mac, net, reason);
		goto out;
	case IW_MLME_DISASSOC:
		ieee80211softmac_send_disassoc_req(mac, reason);
		mac->associnfo.associated = 0;
		mac->associnfo.associating = 0;
		err = 0;
		goto out;
	default:
		err = -EOPNOTSUPP;
	}

out:
	mutex_unlock(&mac->associnfo.mutex);

	return err;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_mlme);
Commit	Line	Data
370121e5 JB	1	/*
370121e5 JB	2	* This file contains our _wx handlers. Make sure you EXPORT_SYMBOL_GPL them
4855d25b	3	*
79859051 JB	4	* Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net>
	5	* Joseph Jezak <josejx@gentoo.org>
	6	* Larry Finger <Larry.Finger@lwfinger.net>
	7	* Danny van Dyk <kugelfang@gentoo.org>
	8	* Michael Buesch <mbuesch@freenet.de>
4855d25b JB	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of version 2 of the GNU General Public License as
	12	* published by the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful, but WITHOUT
	15	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	16	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	17	* more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	22	*
	23	* The full GNU General Public License is included in this distribution in the
	24	* file called COPYING.
370121e5 JB	25	*/
	26
	27	#include "ieee80211softmac_priv.h"
	28
	29	#include <net/iw_handler.h>
818667f7 JB	30	/* for is_broadcast_ether_addr and is_zero_ether_addr */
818667f7 JB	31	#include <linux/etherdevice.h>
370121e5 JB	32
	33	int
	34	ieee80211softmac_wx_trigger_scan(struct net_device *net_dev,
	35	struct iw_request_info *info,
	36	union iwreq_data *data,
	37	char *extra)
	38	{
	39	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);
	40	return ieee80211softmac_start_scan(sm);
	41	}
	42	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_trigger_scan);
	43
	44
ba2f8c18	45	/* if we're still scanning, return -EAGAIN so that userspace tools
ba2f8c18	46	* can get the complete scan results, otherwise return 0. */
370121e5 JB	47	int
	48	ieee80211softmac_wx_get_scan_results(struct net_device *net_dev,
	49	struct iw_request_info *info,
	50	union iwreq_data *data,
	51	char *extra)
	52	{
ba2f8c18	53	unsigned long flags;
370121e5	54	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);
ba2f8c18	55
	56	spin_lock_irqsave(&sm->lock, flags);
	57	if (sm->scanning) {
	58	spin_unlock_irqrestore(&sm->lock, flags);
	59	return -EAGAIN;
	60	}
	61	spin_unlock_irqrestore(&sm->lock, flags);
370121e5 JB	62	return ieee80211_wx_get_scan(sm->ieee, info, data, extra);
	63	}
	64	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_scan_results);
	65
	66	int
	67	ieee80211softmac_wx_set_essid(struct net_device *net_dev,
	68	struct iw_request_info *info,
	69	union iwreq_data *data,
	70	char *extra)
	71	{
	72	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);
cb74c432 JJ	73	struct ieee80211softmac_network *n;
cb74c432 JJ	74	struct ieee80211softmac_auth_queue_item *authptr;
370121e5	75	int length = 0;
7c28ad2d MB	76
7c28ad2d MB	77	mutex_lock(&sm->associnfo.mutex);
cb74c432 JJ	78
	79	/* Check if we're already associating to this or another network
	80	* If it's another network, cancel and start over with our new network
	81	* If it's our network, ignore the change, we're already doing it!
	82	*/
7c28ad2d	83	if((sm->associnfo.associating \|\| sm->associnfo.associated) &&
b978d027	84	(data->essid.flags && data->essid.length)) {
cb74c432 JJ	85	/* Get the associating network */
cb74c432 JJ	86	n = ieee80211softmac_get_network_by_bssid(sm, sm->associnfo.bssid);
b978d027	87	if(n && n->essid.len == data->essid.length &&
cb74c432 JJ	88	!memcmp(n->essid.data, extra, n->essid.len)) {
	89	dprintk(KERN_INFO PFX "Already associating or associated to "MAC_FMT"\n",
	90	MAC_ARG(sm->associnfo.bssid));
7c28ad2d	91	goto out;
cb74c432 JJ	92	} else {
cb74c432 JJ	93	dprintk(KERN_INFO PFX "Canceling existing associate request!\n");
cb74c432 JJ	94	/* Cancel assoc work */
	95	cancel_delayed_work(&sm->associnfo.work);
	96	/* We don't have to do this, but it's a little cleaner */
	97	list_for_each_entry(authptr, &sm->auth_queue, list)
	98	cancel_delayed_work(&authptr->work);
	99	sm->associnfo.bssvalid = 0;
	100	sm->associnfo.bssfixed = 0;
cb74c432	101	flush_scheduled_work();
7c28ad2d MB	102	sm->associnfo.associating = 0;
7c28ad2d MB	103	sm->associnfo.associated = 0;
cb74c432 JJ	104	}
	105	}
	106
	107
370121e5	108	sm->associnfo.static_essid = 0;
cb74c432	109	sm->associnfo.assoc_wait = 0;
370121e5	110
b978d027 LF	111	if (data->essid.flags && data->essid.length) {
b978d027 LF	112	length = min((int)data->essid.length, IW_ESSID_MAX_SIZE);
370121e5 JB	113	if (length) {
	114	memcpy(sm->associnfo.req_essid.data, extra, length);
	115	sm->associnfo.static_essid = 1;
	116	}
	117	}
370121e5 JB	118
	119	/* set our requested ESSID length.
	120	* If applicable, we have already copied the data in */
	121	sm->associnfo.req_essid.len = length;
	122
7c28ad2d	123	sm->associnfo.associating = 1;
370121e5	124	/* queue lower level code to do work (if necessary) */
c4028958	125	schedule_delayed_work(&sm->associnfo.work, 0);
7c28ad2d MB	126	out:
7c28ad2d MB	127	mutex_unlock(&sm->associnfo.mutex);
370121e5	128
370121e5 JB	129	return 0;
	130	}
	131	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_essid);
	132
	133	int
	134	ieee80211softmac_wx_get_essid(struct net_device *net_dev,
	135	struct iw_request_info *info,
	136	union iwreq_data *data,
	137	char *extra)
	138	{
	139	struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);
370121e5	140
7c28ad2d	141	mutex_lock(&sm->associnfo.mutex);
370121e5 JB	142	/* If all fails, return ANY (empty) */
	143	data->essid.length = 0;
	144	data->essid.flags = 0; /* active */
64265651	145
370121e5 JB	146	/* If we have a statically configured ESSID then return it */
	147	if (sm->associnfo.static_essid) {
	148	data->essid.length = sm->associnfo.req_essid.len;
	149	data->essid.flags = 1; /* active */
	150	memcpy(extra, sm->associnfo.req_essid.data, sm->associnfo.req_essid.len);
	151	}
64265651	152
370121e5	153	/* If we're associating/associated, return that */
7c28ad2d	154	if (sm->associnfo.associated \|\| sm->associnfo.associating) {
370121e5 JB	155	data->essid.length = sm->associnfo.associate_essid.len;
	156	data->essid.flags = 1; /* active */
	157	memcpy(extra, sm->associnfo.associate_essid.data, sm->associnfo.associate_essid.len);
	158	}
7c28ad2d MB	159	mutex_unlock(&sm->associnfo.mutex);
7c28ad2d MB	160
370121e5 JB	161	return 0;
	162	}
	163	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_essid);
	164
	165	int
	166	ieee80211softmac_wx_set_rate(struct net_device *net_dev,
	167	struct iw_request_info *info,
	168	union iwreq_data *data,
	169	char *extra)
	170	{
	171	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
	172	struct ieee80211_device *ieee = mac->ieee;
	173	unsigned long flags;
	174	s32 in_rate = data->bitrate.value;
	175	u8 rate;
	176	int is_ofdm = 0;
	177	int err = -EINVAL;
	178
	179	if (in_rate == -1) {
2638fed7 DW	180	/* FIXME: We don't correctly handle backing down to lower
	181	rates, so 801.11g devices start off at 11M for now. People
	182	can manually change it if they really need to, but 11M is
	183	more reliable. Note similar logic in
64265651	184	ieee80211softmac_wx_set_rate() */
2638fed7	185	if (ieee->modulation & IEEE80211_CCK_MODULATION)
370121e5	186	in_rate = 11000000;
2638fed7 DW	187	else
2638fed7 DW	188	in_rate = 54000000;
370121e5 JB	189	}
	190
	191	switch (in_rate) {
	192	case 1000000:
	193	rate = IEEE80211_CCK_RATE_1MB;
	194	break;
	195	case 2000000:
	196	rate = IEEE80211_CCK_RATE_2MB;
	197	break;
	198	case 5500000:
	199	rate = IEEE80211_CCK_RATE_5MB;
	200	break;
	201	case 11000000:
	202	rate = IEEE80211_CCK_RATE_11MB;
	203	break;
	204	case 6000000:
	205	rate = IEEE80211_OFDM_RATE_6MB;
	206	is_ofdm = 1;
	207	break;
	208	case 9000000:
	209	rate = IEEE80211_OFDM_RATE_9MB;
	210	is_ofdm = 1;
	211	break;
	212	case 12000000:
	213	rate = IEEE80211_OFDM_RATE_12MB;
	214	is_ofdm = 1;
	215	break;
	216	case 18000000:
	217	rate = IEEE80211_OFDM_RATE_18MB;
	218	is_ofdm = 1;
	219	break;
	220	case 24000000:
	221	rate = IEEE80211_OFDM_RATE_24MB;
	222	is_ofdm = 1;
	223	break;
	224	case 36000000:
	225	rate = IEEE80211_OFDM_RATE_36MB;
	226	is_ofdm = 1;
	227	break;
	228	case 48000000:
	229	rate = IEEE80211_OFDM_RATE_48MB;
	230	is_ofdm = 1;
	231	break;
	232	case 54000000:
	233	rate = IEEE80211_OFDM_RATE_54MB;
	234	is_ofdm = 1;
	235	break;
	236	default:
	237	goto out;
	238	}
	239
	240	spin_lock_irqsave(&mac->lock, flags);
	241
	242	/* Check if correct modulation for this PHY. */
	243	if (is_ofdm && !(ieee->modulation & IEEE80211_OFDM_MODULATION))
	244	goto out_unlock;
	245
8462fe3c DD	246	mac->txrates.user_rate = rate;
8462fe3c DD	247	ieee80211softmac_recalc_txrates(mac);
370121e5 JB	248	err = 0;
370121e5 JB	249
64265651	250	out_unlock:
370121e5 JB	251	spin_unlock_irqrestore(&mac->lock, flags);
	252	out:
	253	return err;
	254	}
	255	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_rate);
	256
	257	int
	258	ieee80211softmac_wx_get_rate(struct net_device *net_dev,
	259	struct iw_request_info *info,
	260	union iwreq_data *data,
	261	char *extra)
	262	{
	263	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
	264	unsigned long flags;
	265	int err = -EINVAL;
	266
	267	spin_lock_irqsave(&mac->lock, flags);
6bbdce5a JL	268
	269	if (unlikely(!mac->running)) {
	270	err = -ENODEV;
	271	goto out_unlock;
	272	}
	273
370121e5 JB	274	switch (mac->txrates.default_rate) {
	275	case IEEE80211_CCK_RATE_1MB:
	276	data->bitrate.value = 1000000;
	277	break;
	278	case IEEE80211_CCK_RATE_2MB:
	279	data->bitrate.value = 2000000;
	280	break;
	281	case IEEE80211_CCK_RATE_5MB:
	282	data->bitrate.value = 5500000;
	283	break;
	284	case IEEE80211_CCK_RATE_11MB:
	285	data->bitrate.value = 11000000;
	286	break;
	287	case IEEE80211_OFDM_RATE_6MB:
	288	data->bitrate.value = 6000000;
	289	break;
	290	case IEEE80211_OFDM_RATE_9MB:
	291	data->bitrate.value = 9000000;
	292	break;
	293	case IEEE80211_OFDM_RATE_12MB:
	294	data->bitrate.value = 12000000;
	295	break;
	296	case IEEE80211_OFDM_RATE_18MB:
	297	data->bitrate.value = 18000000;
	298	break;
	299	case IEEE80211_OFDM_RATE_24MB:
	300	data->bitrate.value = 24000000;
	301	break;
	302	case IEEE80211_OFDM_RATE_36MB:
	303	data->bitrate.value = 36000000;
	304	break;
	305	case IEEE80211_OFDM_RATE_48MB:
	306	data->bitrate.value = 48000000;
	307	break;
	308	case IEEE80211_OFDM_RATE_54MB:
	309	data->bitrate.value = 54000000;
	310	break;
	311	default:
	312	assert(0);
	313	goto out_unlock;
	314	}
	315	err = 0;
	316	out_unlock:
	317	spin_unlock_irqrestore(&mac->lock, flags);
	318
	319	return err;
	320	}
	321	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_rate);
	322
	323	int
	324	ieee80211softmac_wx_get_wap(struct net_device *net_dev,
	325	struct iw_request_info *info,
	326	union iwreq_data *data,
	327	char *extra)
	328	{
	329	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
	330	int err = 0;
370121e5	331
7c28ad2d	332	mutex_lock(&mac->associnfo.mutex);
370121e5 JB	333	if (mac->associnfo.bssvalid)
	334	memcpy(data->ap_addr.sa_data, mac->associnfo.bssid, ETH_ALEN);
	335	else
	336	memset(data->ap_addr.sa_data, 0xff, ETH_ALEN);
	337	data->ap_addr.sa_family = ARPHRD_ETHER;
7c28ad2d MB	338	mutex_unlock(&mac->associnfo.mutex);
7c28ad2d MB	339
370121e5 JB	340	return err;
	341	}
	342	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_wap);
	343
	344	int
	345	ieee80211softmac_wx_set_wap(struct net_device *net_dev,
	346	struct iw_request_info *info,
	347	union iwreq_data *data,
	348	char *extra)
	349	{
	350	struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
370121e5 JB	351
	352	/* sanity check */
	353	if (data->ap_addr.sa_family != ARPHRD_ETHER) {
	354	return -EINVAL;
	355	}
	356
7c28ad2d	357	mutex_lock(&mac->associnfo.mutex);
818667f7 JB	358	if (is_broadcast_ether_addr(data->ap_addr.sa_data)) {
	359	/* the bssid we have is not to be fixed any longer,
	360	* and we should reassociate to the best AP. */
	361	mac->associnfo.bssfixed = 0;
	362	/* force reassociation */
	363	mac->associnfo.bssvalid = 0;
7c28ad2d	364	if (mac->associnfo.associated)
c4028958	365	schedule_delayed_work(&mac->associnfo.work, 0);
818667f7 JB	366	} else if (is_zero_ether_addr(data->ap_addr.sa_data)) {
	367	/* the bssid we have is no longer fixed */
	368	mac->associnfo.bssfixed = 0;
64265651	369	} else {
370121e5	370	if (!memcmp(mac->associnfo.bssid, data->ap_addr.sa_data, ETH_ALEN)) {
7c28ad2d	371	if (mac->associnfo.associating \|\| mac->associnfo.associated) {
370121e5 JB	372	/* bssid unchanged and associated or associating - just return */
	373	goto out;
	374	}
	375	} else {
	376	/* copy new value in data->ap_addr.sa_data to bssid */
	377	memcpy(mac->associnfo.bssid, data->ap_addr.sa_data, ETH_ALEN);
818667f7 JB	378	}
	379	/* tell the other code that this bssid should be used no matter what */
	380	mac->associnfo.bssfixed = 1;
370121e5	381	/* queue associate if new bssid or (old one again and not associated) */
c4028958	382	schedule_delayed_work(&mac->associnfo.work, 0);
64265651	383	}
370121e5	384
818667f7	385	out:
7c28ad2d MB	386	mutex_unlock(&mac->associnfo.mutex);
7c28ad2d MB	387
370121e5 JB	388	return 0;
	389	}
	390	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_wap);
	391
	392	int
	393	ieee80211softmac_wx_set_genie(struct net_device *dev,
	394	struct iw_request_info *info,
	395	union iwreq_data *wrqu,
	396	char *extra)
	397	{
	398	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	399	unsigned long flags;
	400	int err = 0;
	401	char *buf;
	402	int i;
7c28ad2d MB	403
7c28ad2d MB	404	mutex_lock(&mac->associnfo.mutex);
370121e5 JB	405	spin_lock_irqsave(&mac->lock, flags);
	406	/* bleh. shouldn't be locked for that kmalloc... */
	407
	408	if (wrqu->data.length) {
	409	if ((wrqu->data.length < 2) \|\| (extra[1]+2 != wrqu->data.length)) {
	410	/* this is an IE, so the length must be
	411	* correct. Is it possible though that
	412	* more than one IE is passed in?
	413	*/
	414	err = -EINVAL;
	415	goto out;
	416	}
	417	if (mac->wpa.IEbuflen <= wrqu->data.length) {
	418	buf = kmalloc(wrqu->data.length, GFP_ATOMIC);
	419	if (!buf) {
	420	err = -ENOMEM;
	421	goto out;
	422	}
	423	kfree(mac->wpa.IE);
	424	mac->wpa.IE = buf;
	425	mac->wpa.IEbuflen = wrqu->data.length;
	426	}
	427	memcpy(mac->wpa.IE, extra, wrqu->data.length);
	428	dprintk(KERN_INFO PFX "generic IE set to ");
	429	for (i=0;i<wrqu->data.length;i++)
7bd6b918	430	dprintk("%.2x", (u8)mac->wpa.IE[i]);
370121e5 JB	431	dprintk("\n");
	432	mac->wpa.IElen = wrqu->data.length;
	433	} else {
	434	kfree(mac->wpa.IE);
	435	mac->wpa.IE = NULL;
	436	mac->wpa.IElen = 0;
	437	mac->wpa.IEbuflen = 0;
	438	}
	439
64265651	440	out:
370121e5	441	spin_unlock_irqrestore(&mac->lock, flags);
7c28ad2d MB	442	mutex_unlock(&mac->associnfo.mutex);
7c28ad2d MB	443
370121e5 JB	444	return err;
	445	}
	446	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_genie);
	447
	448	int
	449	ieee80211softmac_wx_get_genie(struct net_device *dev,
	450	struct iw_request_info *info,
	451	union iwreq_data *wrqu,
	452	char *extra)
	453	{
	454	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	455	unsigned long flags;
	456	int err = 0;
	457	int space = wrqu->data.length;
7c28ad2d MB	458
7c28ad2d MB	459	mutex_lock(&mac->associnfo.mutex);
370121e5	460	spin_lock_irqsave(&mac->lock, flags);
64265651	461
370121e5	462	wrqu->data.length = 0;
64265651	463
370121e5 JB	464	if (mac->wpa.IE && mac->wpa.IElen) {
	465	wrqu->data.length = mac->wpa.IElen;
	466	if (mac->wpa.IElen <= space)
	467	memcpy(extra, mac->wpa.IE, mac->wpa.IElen);
	468	else
	469	err = -E2BIG;
	470	}
	471	spin_unlock_irqrestore(&mac->lock, flags);
0c234ae6	472	mutex_unlock(&mac->associnfo.mutex);
7c28ad2d	473
370121e5 JB	474	return err;
	475	}
	476	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_genie);
	477
9a1771e8 JB	478	int
	479	ieee80211softmac_wx_set_mlme(struct net_device *dev,
	480	struct iw_request_info *info,
	481	union iwreq_data *wrqu,
	482	char *extra)
	483	{
	484	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	485	struct iw_mlme mlme = (struct iw_mlme )extra;
	486	u16 reason = cpu_to_le16(mlme->reason_code);
	487	struct ieee80211softmac_network *net;
7c28ad2d MB	488	int err = -EINVAL;
	489
	490	mutex_lock(&mac->associnfo.mutex);
9a1771e8 JB	491
	492	if (memcmp(mac->associnfo.bssid, mlme->addr.sa_data, ETH_ALEN)) {
	493	printk(KERN_DEBUG PFX "wx_set_mlme: requested operation on net we don't use\n");
7c28ad2d	494	goto out;
9a1771e8 JB	495	}
	496
	497	switch (mlme->cmd) {
	498	case IW_MLME_DEAUTH:
	499	net = ieee80211softmac_get_network_by_bssid_locked(mac, mlme->addr.sa_data);
	500	if (!net) {
	501	printk(KERN_DEBUG PFX "wx_set_mlme: we should know the net here...\n");
7c28ad2d	502	goto out;
9a1771e8	503	}
cc8ce997 MA	504	err = ieee80211softmac_deauth_req(mac, net, reason);
cc8ce997 MA	505	goto out;
9a1771e8	506	case IW_MLME_DISASSOC:
6d92f83f	507	ieee80211softmac_send_disassoc_req(mac, reason);
7c28ad2d MB	508	mac->associnfo.associated = 0;
	509	mac->associnfo.associating = 0;
	510	err = 0;
	511	goto out;
9a1771e8	512	default:
7c28ad2d	513	err = -EOPNOTSUPP;
9a1771e8	514	}
7c28ad2d MB	515
	516	out:
	517	mutex_unlock(&mac->associnfo.mutex);
	518
	519	return err;
9a1771e8 JB	520	}
9a1771e8 JB	521	EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_mlme);