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