[mirror_ubuntu-zesty-kernel.git] / net / ieee80211 / softmac / ieee80211softmac_module.c

#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;

	/* should we also assign softmac->mgmt_xmit here so
	 * that it is always valid? If so, we probably want
	 * to define a new function for that which just
	 * wraps ieee80211_tx_frame
	 */
	
	/* until associated, we're not ready */
	dev->flags &= ~IFF_RUNNING;

	return dev;

err_free_ieee80211:
 	free_ieee80211(dev);

	return NULL;
}

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

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