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

/*
 * Contains some basic softmac functions along with module registration code etc.
 *
 * Copyright (c) 2005 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_disassoc = ieee80211softmac_handle_disassoc;
	softmac->scaninfo = NULL;

	/* 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;
}

/* 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);
}

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);
}

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;
	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 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
		assert(0);
	if (mac->txrates_change)
		mac->txrates_change(dev, change, &oldrates);
}

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

	ieee80211softmac_clear_pending_work(mac);
}

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);
}

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);
}

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");

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