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

/*
 * Contains some basic softmac functions along with module registration code etc.
 *
 * 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 <linux/sort.h>

struct net_device *alloc_ieee80211softmac(int sizeof_priv)
{
	struct ieee80211softmac_device *softmac;
	struct net_device *dev;
	
	dev = alloc_ieee80211(sizeof(struct ieee80211softmac_device) + sizeof_priv);
	softmac = ieee80211_priv(dev);
	softmac->dev = dev;
	softmac->ieee = netdev_priv(dev);
	spin_lock_init(&softmac->lock);
	
	softmac->ieee->handle_auth = ieee80211softmac_auth_resp;
	softmac->ieee->handle_deauth = ieee80211softmac_deauth_resp;
	softmac->ieee->handle_assoc_response = ieee80211softmac_handle_assoc_response;
	softmac->ieee->handle_reassoc_request = ieee80211softmac_handle_reassoc_req;
	softmac->ieee->handle_disassoc = ieee80211softmac_handle_disassoc;
	softmac->scaninfo = NULL;

	softmac->associnfo.scan_retry = IEEE80211SOFTMAC_ASSOC_SCAN_RETRY_LIMIT;

	/* TODO: initialise all the other callbacks in the ieee struct
	 *	 (once they're written)
	 */

	INIT_LIST_HEAD(&softmac->auth_queue);
	INIT_LIST_HEAD(&softmac->network_list);
	INIT_LIST_HEAD(&softmac->events);

	INIT_WORK(&softmac->associnfo.work, ieee80211softmac_assoc_work, softmac);
	INIT_WORK(&softmac->associnfo.timeout, ieee80211softmac_assoc_timeout, softmac);
	softmac->start_scan = ieee80211softmac_start_scan_implementation;
	softmac->wait_for_scan = ieee80211softmac_wait_for_scan_implementation;
	softmac->stop_scan = ieee80211softmac_stop_scan_implementation;

	//TODO: The mcast rate has to be assigned dynamically somewhere (in scanning, association. Not sure...)
	//      It has to be set to the highest rate all stations in the current network can handle.
	softmac->txrates.mcast_rate = IEEE80211_CCK_RATE_1MB;
	softmac->txrates.mcast_fallback = IEEE80211_CCK_RATE_1MB;
	/* This is reassigned in ieee80211softmac_start to sane values. */
	softmac->txrates.default_rate = IEEE80211_CCK_RATE_1MB;
	softmac->txrates.default_fallback = IEEE80211_CCK_RATE_1MB;

	/* to start with, we can't send anything ... */
	netif_carrier_off(dev);
	
	return dev;
}
EXPORT_SYMBOL_GPL(alloc_ieee80211softmac);

/* Clears the pending work queue items, stops all scans, etc. */
void 
ieee80211softmac_clear_pending_work(struct ieee80211softmac_device *sm)
{
	unsigned long flags;
	struct ieee80211softmac_event *eventptr, *eventtmp;
	struct ieee80211softmac_auth_queue_item *authptr, *authtmp;
	struct ieee80211softmac_network *netptr, *nettmp;
	
	ieee80211softmac_stop_scan(sm);
	ieee80211softmac_wait_for_scan(sm);
	
	spin_lock_irqsave(&sm->lock, flags);
	sm->running = 0;

	/* Free all pending assoc work items */
	cancel_delayed_work(&sm->associnfo.work);
	
	/* Free all pending scan work items */
	if(sm->scaninfo != NULL)
		cancel_delayed_work(&sm->scaninfo->softmac_scan);	
	
	/* Free all pending auth work items */
	list_for_each_entry(authptr, &sm->auth_queue, list)
		cancel_delayed_work(&authptr->work);
	
	/* delete all pending event calls and work items */
	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list)
		cancel_delayed_work(&eventptr->work);

	spin_unlock_irqrestore(&sm->lock, flags);
	flush_scheduled_work();

	/* now we should be save and no longer need locking... */
	spin_lock_irqsave(&sm->lock, flags);
	/* Free all pending auth work items */
	list_for_each_entry_safe(authptr, authtmp, &sm->auth_queue, list) {
		list_del(&authptr->list);
		kfree(authptr);
	}
	
	/* delete all pending event calls and work items */
	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list) {
		list_del(&eventptr->list);
		kfree(eventptr);
	}
		
	/* Free all networks */
	list_for_each_entry_safe(netptr, nettmp, &sm->network_list, list) {
		ieee80211softmac_del_network_locked(sm, netptr);
		if(netptr->challenge != NULL)
			kfree(netptr->challenge);
		kfree(netptr);
	}

	spin_unlock_irqrestore(&sm->lock, flags);
}
EXPORT_SYMBOL_GPL(ieee80211softmac_clear_pending_work);

void free_ieee80211softmac(struct net_device *dev)
{
	struct ieee80211softmac_device *sm = ieee80211_priv(dev);
	ieee80211softmac_clear_pending_work(sm);	
	kfree(sm->scaninfo);
	kfree(sm->wpa.IE);
	free_ieee80211(dev);
}
EXPORT_SYMBOL_GPL(free_ieee80211softmac);

static void ieee80211softmac_start_check_rates(struct ieee80211softmac_device *mac)
{
	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
	/* I took out the sorting check, we're seperating by modulation now. */
	if (ri->count)
		return;
	/* otherwise assume we hav'em all! */
	if (mac->ieee->modulation & IEEE80211_CCK_MODULATION) {
		ri->rates[ri->count++] = IEEE80211_CCK_RATE_1MB;
		ri->rates[ri->count++] = IEEE80211_CCK_RATE_2MB;
		ri->rates[ri->count++] = IEEE80211_CCK_RATE_5MB;
		ri->rates[ri->count++] = IEEE80211_CCK_RATE_11MB;
	}
	if (mac->ieee->modulation & IEEE80211_OFDM_MODULATION) {
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_6MB;
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_9MB;
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_12MB;
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_18MB;
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_24MB;
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_36MB;
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_48MB;
		ri->rates[ri->count++] = IEEE80211_OFDM_RATE_54MB;
	}
}

void ieee80211softmac_start(struct net_device *dev)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	struct ieee80211_device *ieee = mac->ieee;
	u32 change = 0;
	struct ieee80211softmac_txrates oldrates;

	ieee80211softmac_start_check_rates(mac);

	/* TODO: We need some kind of state machine to lower the default rates
	 *       if we loose too many packets.
	 */
	/* Change the default txrate to the highest possible value.
	 * The txrate machine will lower it, if it is too high.
	 */
	if (mac->txrates_change)
		oldrates = mac->txrates;
	/* 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) {
		mac->txrates.default_rate = IEEE80211_CCK_RATE_11MB;
		change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
		mac->txrates.default_fallback = IEEE80211_CCK_RATE_5MB;
		change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	} else if (ieee->modulation & IEEE80211_OFDM_MODULATION) {
		mac->txrates.default_rate = IEEE80211_OFDM_RATE_54MB;
		change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
		mac->txrates.default_fallback = IEEE80211_OFDM_RATE_24MB;
		change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	} else
		assert(0);
	if (mac->txrates_change)
		mac->txrates_change(dev, change, &oldrates);

	mac->running = 1;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_start);

void ieee80211softmac_stop(struct net_device *dev)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);

	ieee80211softmac_clear_pending_work(mac);
}
EXPORT_SYMBOL_GPL(ieee80211softmac_stop);

void ieee80211softmac_set_rates(struct net_device *dev, u8 count, u8 *rates)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	unsigned long flags;
	
	spin_lock_irqsave(&mac->lock, flags);
	memcpy(mac->ratesinfo.rates, rates, count);
	mac->ratesinfo.count = count;
	spin_unlock_irqrestore(&mac->lock, flags);
}
EXPORT_SYMBOL_GPL(ieee80211softmac_set_rates);

static u8 raise_rate(struct ieee80211softmac_device *mac, u8 rate)
{
	int i;
	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
	
	for (i=0; i<ri->count-1; i++) {
		if (ri->rates[i] == rate)
			return ri->rates[i+1];
	}
	/* I guess we can't go any higher... */
	return ri->rates[ri->count];
}

u8 ieee80211softmac_lower_rate_delta(struct ieee80211softmac_device *mac, u8 rate, int delta)
{
	int i;
	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
	
	for (i=delta; i<ri->count; i++) {
		if (ri->rates[i] == rate)
			return ri->rates[i-delta];
	}
	/* I guess we can't go any lower... */
	return ri->rates[0];
}

static void ieee80211softmac_add_txrates_badness(struct ieee80211softmac_device *mac,
						 int amount)
{
	struct ieee80211softmac_txrates oldrates;
	u8 default_rate = mac->txrates.default_rate;
	u8 default_fallback = mac->txrates.default_fallback;
	u32 changes = 0;

	//TODO: This is highly experimental code.
	//      Maybe the dynamic rate selection does not work
	//      and it has to be removed again.

printk("badness %d\n", mac->txrate_badness);
	mac->txrate_badness += amount;
	if (mac->txrate_badness <= -1000) {
		/* Very small badness. Try a faster bitrate. */
		if (mac->txrates_change)
			memcpy(&oldrates, &mac->txrates, sizeof(oldrates));
		default_rate = raise_rate(mac, default_rate);
		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
		default_fallback = get_fallback_rate(mac, default_rate);
		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
		mac->txrate_badness = 0;
printk("Bitrate raised to %u\n", default_rate);
	} else if (mac->txrate_badness >= 10000) {
		/* Very high badness. Try a slower bitrate. */
		if (mac->txrates_change)
			memcpy(&oldrates, &mac->txrates, sizeof(oldrates));
		default_rate = lower_rate(mac, default_rate);
		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
		default_fallback = get_fallback_rate(mac, default_rate);
		changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
		mac->txrate_badness = 0;
printk("Bitrate lowered to %u\n", default_rate);
	}

	mac->txrates.default_rate = default_rate;
	mac->txrates.default_fallback = default_fallback;

	if (changes && mac->txrates_change)
		mac->txrates_change(mac->dev, changes, &oldrates);
}

void ieee80211softmac_fragment_lost(struct net_device *dev,
				    u16 wl_seq)
{
	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	unsigned long flags;

	spin_lock_irqsave(&mac->lock, flags);
	ieee80211softmac_add_txrates_badness(mac, 1000);
	//TODO

	spin_unlock_irqrestore(&mac->lock, flags);
}
EXPORT_SYMBOL_GPL(ieee80211softmac_fragment_lost);

static int rate_cmp(const void *a_, const void *b_) {
	u8 *a, *b;
	a = (u8*)a_;
	b = (u8*)b_;
	return ((*a & ~IEEE80211_BASIC_RATE_MASK) - (*b & ~IEEE80211_BASIC_RATE_MASK));
}

/* Allocate a softmac network struct and fill it from a network */
struct ieee80211softmac_network *
ieee80211softmac_create_network(struct ieee80211softmac_device *mac,
	struct ieee80211_network *net)
{
	struct ieee80211softmac_network *softnet;
	softnet = kzalloc(sizeof(struct ieee80211softmac_network), GFP_ATOMIC);
	if(softnet == NULL)
		return NULL;
	memcpy(softnet->bssid, net->bssid, ETH_ALEN);
	softnet->channel = net->channel;
	softnet->essid.len = net->ssid_len;
	memcpy(softnet->essid.data, net->ssid, softnet->essid.len);
	
	/* copy rates over */
	softnet->supported_rates.count = net->rates_len;
	memcpy(&softnet->supported_rates.rates[0], net->rates, net->rates_len);
	memcpy(&softnet->supported_rates.rates[softnet->supported_rates.count], net->rates_ex, net->rates_ex_len);
	softnet->supported_rates.count += net->rates_ex_len;
	sort(softnet->supported_rates.rates, softnet->supported_rates.count, sizeof(softnet->supported_rates.rates[0]), rate_cmp, NULL);
	
	softnet->capabilities = net->capability;
	return softnet;
}


/* Add a network to the list, while locked */
void
ieee80211softmac_add_network_locked(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_network *add_net)
{
	struct list_head *list_ptr;
	struct ieee80211softmac_network *softmac_net = NULL;

	list_for_each(list_ptr, &mac->network_list) {
		softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
		if(!memcmp(softmac_net->bssid, add_net->bssid, ETH_ALEN))
			break;
		else
			softmac_net = NULL;
	}
	if(softmac_net == NULL)
		list_add(&(add_net->list), &mac->network_list);
}

/* Add a network to the list, with locking */
void
ieee80211softmac_add_network(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_network *add_net)
{
	unsigned long flags;
	spin_lock_irqsave(&mac->lock, flags);
	ieee80211softmac_add_network_locked(mac, add_net);
	spin_unlock_irqrestore(&mac->lock, flags);
}


/* Delete a network from the list, while locked*/
void
ieee80211softmac_del_network_locked(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_network *del_net)
{
	list_del(&(del_net->list));
}

/* Delete a network from the list with locking */
void
ieee80211softmac_del_network(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_network *del_net)
{
	unsigned long flags;
	spin_lock_irqsave(&mac->lock, flags);
	ieee80211softmac_del_network_locked(mac, del_net);
	spin_unlock_irqrestore(&mac->lock, flags);
}

/* Get a network from the list by MAC while locked */
struct ieee80211softmac_network *
ieee80211softmac_get_network_by_bssid_locked(struct ieee80211softmac_device *mac,
	u8 *bssid)
{
	struct list_head *list_ptr;
	struct ieee80211softmac_network *softmac_net = NULL;
	list_for_each(list_ptr, &mac->network_list) {
		softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
		if(!memcmp(softmac_net->bssid, bssid, ETH_ALEN))
			break;
		else
			softmac_net = NULL;
	}
	return softmac_net;
}

/* Get a network from the list by BSSID with locking */
struct ieee80211softmac_network *
ieee80211softmac_get_network_by_bssid(struct ieee80211softmac_device *mac,
	u8 *bssid)
{
	unsigned long flags;
	struct ieee80211softmac_network *softmac_net;
	
	spin_lock_irqsave(&mac->lock, flags);
	softmac_net = ieee80211softmac_get_network_by_bssid_locked(mac, bssid);
	spin_unlock_irqrestore(&mac->lock, flags);
	return softmac_net;
}

/* Get a network from the list by ESSID while locked */
struct ieee80211softmac_network *
ieee80211softmac_get_network_by_essid_locked(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_essid *essid)
{
	struct list_head *list_ptr;
	struct ieee80211softmac_network *softmac_net = NULL;

	list_for_each(list_ptr, &mac->network_list) {
		softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
		if (softmac_net->essid.len == essid->len &&
			!memcmp(softmac_net->essid.data, essid->data, essid->len))
			return softmac_net;
	}
	return NULL;
}

/* Get a network from the list by ESSID with locking */
struct ieee80211softmac_network *
ieee80211softmac_get_network_by_essid(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_essid *essid)	
{
	unsigned long flags;
	struct ieee80211softmac_network *softmac_net = NULL;

	spin_lock_irqsave(&mac->lock, flags);
	softmac_net = ieee80211softmac_get_network_by_essid_locked(mac, essid);	
	spin_unlock_irqrestore(&mac->lock, flags);
	return softmac_net;
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Johannes Berg");
MODULE_AUTHOR("Joseph Jezak");
MODULE_AUTHOR("Larry Finger");
MODULE_AUTHOR("Danny van Dyk");
MODULE_AUTHOR("Michael Buesch");
MODULE_DESCRIPTION("802.11 software MAC");
Commit	Line	Data
4855d25b JB	1	/*
	2	* Contains some basic softmac functions along with module registration code etc.
	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.
	25	*/
	26
370121e5 JB	27	#include "ieee80211softmac_priv.h"
	28	#include <linux/sort.h>
	29
	30	struct net_device *alloc_ieee80211softmac(int sizeof_priv)
	31	{
	32	struct ieee80211softmac_device *softmac;
	33	struct net_device *dev;
	34
	35	dev = alloc_ieee80211(sizeof(struct ieee80211softmac_device) + sizeof_priv);
	36	softmac = ieee80211_priv(dev);
	37	softmac->dev = dev;
	38	softmac->ieee = netdev_priv(dev);
	39	spin_lock_init(&softmac->lock);
	40
	41	softmac->ieee->handle_auth = ieee80211softmac_auth_resp;
	42	softmac->ieee->handle_deauth = ieee80211softmac_deauth_resp;
	43	softmac->ieee->handle_assoc_response = ieee80211softmac_handle_assoc_response;
b6c7658e	44	softmac->ieee->handle_reassoc_request = ieee80211softmac_handle_reassoc_req;
370121e5 JB	45	softmac->ieee->handle_disassoc = ieee80211softmac_handle_disassoc;
	46	softmac->scaninfo = NULL;
	47
818667f7 JB	48	softmac->associnfo.scan_retry = IEEE80211SOFTMAC_ASSOC_SCAN_RETRY_LIMIT;
818667f7 JB	49
370121e5 JB	50	/* TODO: initialise all the other callbacks in the ieee struct
	51	* (once they're written)
	52	*/
	53
370121e5 JB	54	INIT_LIST_HEAD(&softmac->auth_queue);
	55	INIT_LIST_HEAD(&softmac->network_list);
	56	INIT_LIST_HEAD(&softmac->events);
	57
	58	INIT_WORK(&softmac->associnfo.work, ieee80211softmac_assoc_work, softmac);
	59	INIT_WORK(&softmac->associnfo.timeout, ieee80211softmac_assoc_timeout, softmac);
	60	softmac->start_scan = ieee80211softmac_start_scan_implementation;
	61	softmac->wait_for_scan = ieee80211softmac_wait_for_scan_implementation;
	62	softmac->stop_scan = ieee80211softmac_stop_scan_implementation;
	63
	64	//TODO: The mcast rate has to be assigned dynamically somewhere (in scanning, association. Not sure...)
	65	// It has to be set to the highest rate all stations in the current network can handle.
	66	softmac->txrates.mcast_rate = IEEE80211_CCK_RATE_1MB;
	67	softmac->txrates.mcast_fallback = IEEE80211_CCK_RATE_1MB;
	68	/* This is reassigned in ieee80211softmac_start to sane values. */
	69	softmac->txrates.default_rate = IEEE80211_CCK_RATE_1MB;
	70	softmac->txrates.default_fallback = IEEE80211_CCK_RATE_1MB;
	71
2dd50801 JB	72	/* to start with, we can't send anything ... */
2dd50801 JB	73	netif_carrier_off(dev);
370121e5	74
370121e5	75	return dev;
370121e5	76	}
4c718cfd	77	EXPORT_SYMBOL_GPL(alloc_ieee80211softmac);
370121e5 JB	78
	79	/* Clears the pending work queue items, stops all scans, etc. */
	80	void
	81	ieee80211softmac_clear_pending_work(struct ieee80211softmac_device *sm)
	82	{
	83	unsigned long flags;
	84	struct ieee80211softmac_event eventptr, eventtmp;
	85	struct ieee80211softmac_auth_queue_item authptr, authtmp;
	86	struct ieee80211softmac_network netptr, nettmp;
	87
	88	ieee80211softmac_stop_scan(sm);
	89	ieee80211softmac_wait_for_scan(sm);
	90
	91	spin_lock_irqsave(&sm->lock, flags);
d57336e3 DD	92	sm->running = 0;
d57336e3 DD	93
370121e5 JB	94	/* Free all pending assoc work items */
	95	cancel_delayed_work(&sm->associnfo.work);
	96
	97	/* Free all pending scan work items */
	98	if(sm->scaninfo != NULL)
	99	cancel_delayed_work(&sm->scaninfo->softmac_scan);
	100
	101	/* Free all pending auth work items */
	102	list_for_each_entry(authptr, &sm->auth_queue, list)
	103	cancel_delayed_work(&authptr->work);
	104
	105	/* delete all pending event calls and work items */
	106	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list)
	107	cancel_delayed_work(&eventptr->work);
	108
	109	spin_unlock_irqrestore(&sm->lock, flags);
5c4df6da	110	flush_scheduled_work();
370121e5	111
b2b9b651	112	/* now we should be save and no longer need locking... */
370121e5 JB	113	spin_lock_irqsave(&sm->lock, flags);
	114	/* Free all pending auth work items */
	115	list_for_each_entry_safe(authptr, authtmp, &sm->auth_queue, list) {
	116	list_del(&authptr->list);
	117	kfree(authptr);
	118	}
	119
	120	/* delete all pending event calls and work items */
	121	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list) {
	122	list_del(&eventptr->list);
	123	kfree(eventptr);
	124	}
	125
	126	/* Free all networks */
	127	list_for_each_entry_safe(netptr, nettmp, &sm->network_list, list) {
	128	ieee80211softmac_del_network_locked(sm, netptr);
	129	if(netptr->challenge != NULL)
	130	kfree(netptr->challenge);
	131	kfree(netptr);
	132	}
	133
	134	spin_unlock_irqrestore(&sm->lock, flags);
	135	}
4c718cfd	136	EXPORT_SYMBOL_GPL(ieee80211softmac_clear_pending_work);
370121e5 JB	137
	138	void free_ieee80211softmac(struct net_device *dev)
	139	{
	140	struct ieee80211softmac_device *sm = ieee80211_priv(dev);
	141	ieee80211softmac_clear_pending_work(sm);
370121e5 JB	142	kfree(sm->scaninfo);
	143	kfree(sm->wpa.IE);
	144	free_ieee80211(dev);
	145	}
4c718cfd	146	EXPORT_SYMBOL_GPL(free_ieee80211softmac);
370121e5 JB	147
	148	static void ieee80211softmac_start_check_rates(struct ieee80211softmac_device *mac)
	149	{
	150	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
	151	/* I took out the sorting check, we're seperating by modulation now. */
	152	if (ri->count)
	153	return;
	154	/* otherwise assume we hav'em all! */
	155	if (mac->ieee->modulation & IEEE80211_CCK_MODULATION) {
	156	ri->rates[ri->count++] = IEEE80211_CCK_RATE_1MB;
	157	ri->rates[ri->count++] = IEEE80211_CCK_RATE_2MB;
	158	ri->rates[ri->count++] = IEEE80211_CCK_RATE_5MB;
	159	ri->rates[ri->count++] = IEEE80211_CCK_RATE_11MB;
	160	}
	161	if (mac->ieee->modulation & IEEE80211_OFDM_MODULATION) {
	162	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_6MB;
	163	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_9MB;
	164	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_12MB;
	165	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_18MB;
	166	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_24MB;
	167	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_36MB;
	168	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_48MB;
	169	ri->rates[ri->count++] = IEEE80211_OFDM_RATE_54MB;
	170	}
	171	}
	172
	173	void ieee80211softmac_start(struct net_device *dev)
	174	{
	175	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	176	struct ieee80211_device *ieee = mac->ieee;
	177	u32 change = 0;
	178	struct ieee80211softmac_txrates oldrates;
	179
	180	ieee80211softmac_start_check_rates(mac);
	181
	182	/* TODO: We need some kind of state machine to lower the default rates
	183	* if we loose too many packets.
	184	*/
	185	/* Change the default txrate to the highest possible value.
	186	* The txrate machine will lower it, if it is too high.
	187	*/
	188	if (mac->txrates_change)
	189	oldrates = mac->txrates;
2638fed7 DW	190	/* FIXME: We don't correctly handle backing down to lower
	191	rates, so 801.11g devices start off at 11M for now. People
	192	can manually change it if they really need to, but 11M is
	193	more reliable. Note similar logic in
	194	ieee80211softmac_wx_set_rate() */
	195	if (ieee->modulation & IEEE80211_CCK_MODULATION) {
370121e5 JB	196	mac->txrates.default_rate = IEEE80211_CCK_RATE_11MB;
	197	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	198	mac->txrates.default_fallback = IEEE80211_CCK_RATE_5MB;
	199	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
2638fed7 DW	200	} else if (ieee->modulation & IEEE80211_OFDM_MODULATION) {
	201	mac->txrates.default_rate = IEEE80211_OFDM_RATE_54MB;
	202	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	203	mac->txrates.default_fallback = IEEE80211_OFDM_RATE_24MB;
	204	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
370121e5 JB	205	} else
	206	assert(0);
	207	if (mac->txrates_change)
	208	mac->txrates_change(dev, change, &oldrates);
d57336e3 DD	209
d57336e3 DD	210	mac->running = 1;
370121e5	211	}
4c718cfd	212	EXPORT_SYMBOL_GPL(ieee80211softmac_start);
370121e5 JB	213
	214	void ieee80211softmac_stop(struct net_device *dev)
	215	{
	216	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	217
	218	ieee80211softmac_clear_pending_work(mac);
	219	}
4c718cfd	220	EXPORT_SYMBOL_GPL(ieee80211softmac_stop);
370121e5 JB	221
	222	void ieee80211softmac_set_rates(struct net_device dev, u8 count, u8 rates)
	223	{
	224	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	225	unsigned long flags;
	226
	227	spin_lock_irqsave(&mac->lock, flags);
	228	memcpy(mac->ratesinfo.rates, rates, count);
	229	mac->ratesinfo.count = count;
	230	spin_unlock_irqrestore(&mac->lock, flags);
	231	}
4c718cfd	232	EXPORT_SYMBOL_GPL(ieee80211softmac_set_rates);
370121e5 JB	233
	234	static u8 raise_rate(struct ieee80211softmac_device *mac, u8 rate)
	235	{
	236	int i;
	237	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
	238
	239	for (i=0; i<ri->count-1; i++) {
	240	if (ri->rates[i] == rate)
	241	return ri->rates[i+1];
	242	}
	243	/* I guess we can't go any higher... */
	244	return ri->rates[ri->count];
	245	}
	246
	247	u8 ieee80211softmac_lower_rate_delta(struct ieee80211softmac_device *mac, u8 rate, int delta)
	248	{
	249	int i;
	250	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
	251
	252	for (i=delta; i<ri->count; i++) {
	253	if (ri->rates[i] == rate)
	254	return ri->rates[i-delta];
	255	}
	256	/* I guess we can't go any lower... */
	257	return ri->rates[0];
	258	}
	259
	260	static void ieee80211softmac_add_txrates_badness(struct ieee80211softmac_device *mac,
	261	int amount)
	262	{
	263	struct ieee80211softmac_txrates oldrates;
	264	u8 default_rate = mac->txrates.default_rate;
	265	u8 default_fallback = mac->txrates.default_fallback;
	266	u32 changes = 0;
	267
	268	//TODO: This is highly experimental code.
	269	// Maybe the dynamic rate selection does not work
	270	// and it has to be removed again.
	271
	272	printk("badness %d\n", mac->txrate_badness);
	273	mac->txrate_badness += amount;
	274	if (mac->txrate_badness <= -1000) {
	275	/* Very small badness. Try a faster bitrate. */
	276	if (mac->txrates_change)
	277	memcpy(&oldrates, &mac->txrates, sizeof(oldrates));
	278	default_rate = raise_rate(mac, default_rate);
	279	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	280	default_fallback = get_fallback_rate(mac, default_rate);
	281	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	282	mac->txrate_badness = 0;
	283	printk("Bitrate raised to %u\n", default_rate);
	284	} else if (mac->txrate_badness >= 10000) {
	285	/* Very high badness. Try a slower bitrate. */
	286	if (mac->txrates_change)
	287	memcpy(&oldrates, &mac->txrates, sizeof(oldrates));
	288	default_rate = lower_rate(mac, default_rate);
	289	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	290	default_fallback = get_fallback_rate(mac, default_rate);
	291	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	292	mac->txrate_badness = 0;
	293	printk("Bitrate lowered to %u\n", default_rate);
	294	}
	295
	296	mac->txrates.default_rate = default_rate;
297	mac->txrates.default_fallback = default_fallback;
298
299	if (changes && mac->txrates_change)
300	mac->txrates_change(mac->dev, changes, &oldrates);
301	}
302
303	void ieee80211softmac_fragment_lost(struct net_device *dev,
304	u16 wl_seq)
305	{
306	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
307	unsigned long flags;
308
309	spin_lock_irqsave(&mac->lock, flags);
310	ieee80211softmac_add_txrates_badness(mac, 1000);
311	//TODO
312
313	spin_unlock_irqrestore(&mac->lock, flags);
314	}
4c718cfd	315	EXPORT_SYMBOL_GPL(ieee80211softmac_fragment_lost);
370121e5 JB	316
	317	static int rate_cmp(const void a_, const void b_) {
	318	u8 a, b;
	319	a = (u8*)a_;
	320	b = (u8*)b_;
	321	return ((a & ~IEEE80211_BASIC_RATE_MASK) - (b & ~IEEE80211_BASIC_RATE_MASK));
	322	}
	323
	324	/* Allocate a softmac network struct and fill it from a network */
	325	struct ieee80211softmac_network *
	326	ieee80211softmac_create_network(struct ieee80211softmac_device *mac,
	327	struct ieee80211_network *net)
	328	{
	329	struct ieee80211softmac_network *softnet;
	330	softnet = kzalloc(sizeof(struct ieee80211softmac_network), GFP_ATOMIC);
	331	if(softnet == NULL)
	332	return NULL;
	333	memcpy(softnet->bssid, net->bssid, ETH_ALEN);
	334	softnet->channel = net->channel;
	335	softnet->essid.len = net->ssid_len;
	336	memcpy(softnet->essid.data, net->ssid, softnet->essid.len);
	337
	338	/* copy rates over */
	339	softnet->supported_rates.count = net->rates_len;
	340	memcpy(&softnet->supported_rates.rates[0], net->rates, net->rates_len);
	341	memcpy(&softnet->supported_rates.rates[softnet->supported_rates.count], net->rates_ex, net->rates_ex_len);
	342	softnet->supported_rates.count += net->rates_ex_len;
	343	sort(softnet->supported_rates.rates, softnet->supported_rates.count, sizeof(softnet->supported_rates.rates[0]), rate_cmp, NULL);
	344
	345	softnet->capabilities = net->capability;
	346	return softnet;
	347	}
	348
	349
	350	/* Add a network to the list, while locked */
	351	void
	352	ieee80211softmac_add_network_locked(struct ieee80211softmac_device *mac,
	353	struct ieee80211softmac_network *add_net)
	354	{
	355	struct list_head *list_ptr;
	356	struct ieee80211softmac_network *softmac_net = NULL;
	357
	358	list_for_each(list_ptr, &mac->network_list) {
	359	softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
	360	if(!memcmp(softmac_net->bssid, add_net->bssid, ETH_ALEN))
	361	break;
	362	else
	363	softmac_net = NULL;
	364	}
	365	if(softmac_net == NULL)
	366	list_add(&(add_net->list), &mac->network_list);
	367	}
	368
	369	/* Add a network to the list, with locking */
	370	void
	371	ieee80211softmac_add_network(struct ieee80211softmac_device *mac,
	372	struct ieee80211softmac_network *add_net)
	373	{
	374	unsigned long flags;
	375	spin_lock_irqsave(&mac->lock, flags);
	376	ieee80211softmac_add_network_locked(mac, add_net);
	377	spin_unlock_irqrestore(&mac->lock, flags);
	378	}
	379
380
381	/* Delete a network from the list, while locked*/
382	void
383	ieee80211softmac_del_network_locked(struct ieee80211softmac_device *mac,
384	struct ieee80211softmac_network *del_net)
385	{
386	list_del(&(del_net->list));
387	}
388
389	/* Delete a network from the list with locking */
390	void
391	ieee80211softmac_del_network(struct ieee80211softmac_device *mac,
392	struct ieee80211softmac_network *del_net)
393	{
394	unsigned long flags;
395	spin_lock_irqsave(&mac->lock, flags);
396	ieee80211softmac_del_network_locked(mac, del_net);
397	spin_unlock_irqrestore(&mac->lock, flags);
398	}
399
400	/* Get a network from the list by MAC while locked */
401	struct ieee80211softmac_network *
402	ieee80211softmac_get_network_by_bssid_locked(struct ieee80211softmac_device *mac,
403	u8 *bssid)
404	{
405	struct list_head *list_ptr;
406	struct ieee80211softmac_network *softmac_net = NULL;
407	list_for_each(list_ptr, &mac->network_list) {
408	softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
409	if(!memcmp(softmac_net->bssid, bssid, ETH_ALEN))
410	break;
411	else
412	softmac_net = NULL;
413	}
414	return softmac_net;
415	}
416
417	/* Get a network from the list by BSSID with locking */
418	struct ieee80211softmac_network *
419	ieee80211softmac_get_network_by_bssid(struct ieee80211softmac_device *mac,
420	u8 *bssid)
421	{
422	unsigned long flags;
423	struct ieee80211softmac_network *softmac_net;
424
425	spin_lock_irqsave(&mac->lock, flags);
426	softmac_net = ieee80211softmac_get_network_by_bssid_locked(mac, bssid);
427	spin_unlock_irqrestore(&mac->lock, flags);
428	return softmac_net;
429	}
430
431	/* Get a network from the list by ESSID while locked */
432	struct ieee80211softmac_network *
433	ieee80211softmac_get_network_by_essid_locked(struct ieee80211softmac_device *mac,
434	struct ieee80211softmac_essid *essid)
435	{
436	struct list_head *list_ptr;
437	struct ieee80211softmac_network *softmac_net = NULL;
438
439	list_for_each(list_ptr, &mac->network_list) {
440	softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
441	if (softmac_net->essid.len == essid->len &&
442	!memcmp(softmac_net->essid.data, essid->data, essid->len))
443	return softmac_net;
444	}
445	return NULL;
446	}
447
448	/* Get a network from the list by ESSID with locking */
449	struct ieee80211softmac_network *
450	ieee80211softmac_get_network_by_essid(struct ieee80211softmac_device *mac,
451	struct ieee80211softmac_essid *essid)
452	{
453	unsigned long flags;
454	struct ieee80211softmac_network *softmac_net = NULL;
455
456	spin_lock_irqsave(&mac->lock, flags);
457	softmac_net = ieee80211softmac_get_network_by_essid_locked(mac, essid);
458	spin_unlock_irqrestore(&mac->lock, flags);
459	return softmac_net;
460	}
461
462	MODULE_LICENSE("GPL");
9ebdd466 JB	463	MODULE_AUTHOR("Johannes Berg");
	464	MODULE_AUTHOR("Joseph Jezak");
	465	MODULE_AUTHOR("Larry Finger");
	466	MODULE_AUTHOR("Danny van Dyk");
	467	MODULE_AUTHOR("Michael Buesch");
	468	MODULE_DESCRIPTION("802.11 software MAC");