[mirror_ubuntu-zesty-kernel.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>
#include <linux/etherdevice.h>

struct net_device *alloc_ieee80211softmac(int sizeof_priv)
{
	struct ieee80211softmac_device *softmac;
	struct net_device *dev;

	dev = alloc_ieee80211(sizeof(*softmac) + sizeof_priv);
	if (!dev)
		return NULL;

	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->ieee->handle_beacon = ieee80211softmac_handle_beacon;
	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);

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

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

	return dev;
}
EXPORT_SYMBOL_GPL(alloc_ieee80211softmac);

/* Clears the pending work queue items, stops all scans, etc. */
void
ieee80211softmac_clear_pending_work(struct ieee80211softmac_device *sm)
{
	unsigned long flags;
	struct ieee80211softmac_event *eventptr, *eventtmp;
	struct ieee80211softmac_auth_queue_item *authptr, *authtmp;
	struct ieee80211softmac_network *netptr, *nettmp;

	ieee80211softmac_stop_scan(sm);
	ieee80211softmac_wait_for_scan(sm);

	spin_lock_irqsave(&sm->lock, flags);
	sm->running = 0;

	/* Free all pending assoc work items */
	cancel_delayed_work(&sm->associnfo.work);

	/* Free all pending scan work items */
	if(sm->scaninfo != NULL)
		cancel_delayed_work(&sm->scaninfo->softmac_scan);

	/* Free all pending auth work items */
	list_for_each_entry(authptr, &sm->auth_queue, list)
		cancel_delayed_work(&authptr->work);

	/* delete all pending event calls and work items */
	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list)
		cancel_delayed_work(&eventptr->work);

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

	/* now we should be save and no longer need locking... */
	spin_lock_irqsave(&sm->lock, flags);
	/* Free all pending auth work items */
	list_for_each_entry_safe(authptr, authtmp, &sm->auth_queue, list) {
		list_del(&authptr->list);
		kfree(authptr);
	}

	/* delete all pending event calls and work items */
	list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list) {
		list_del(&eventptr->list);
		kfree(eventptr);
	}

	/* Free all networks */
	list_for_each_entry_safe(netptr, nettmp, &sm->network_list, list) {
		ieee80211softmac_del_network_locked(sm, netptr);
		if(netptr->challenge != NULL)
			kfree(netptr->challenge);
		kfree(netptr);
	}

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

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

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

int ieee80211softmac_ratesinfo_rate_supported(struct ieee80211softmac_ratesinfo *ri, u8 rate)
{
	int search;
	u8 search_rate;

	for (search = 0; search < ri->count; search++) {
		search_rate = ri->rates[search];
		search_rate &= ~IEEE80211_BASIC_RATE_MASK;
		if (rate == search_rate)
			return 1;
	}

	return 0;
}

u8 ieee80211softmac_highest_supported_rate(struct ieee80211softmac_device *mac,
	struct ieee80211softmac_ratesinfo *ri, int basic_only)
{
	u8 user_rate = mac->txrates.user_rate;
	int i;

	if (ri->count == 0)
		return IEEE80211_CCK_RATE_1MB;

	for (i = ri->count - 1; i >= 0; i--) {
		u8 rate = ri->rates[i];
		if (basic_only && !(rate & IEEE80211_BASIC_RATE_MASK))
			continue;
		rate &= ~IEEE80211_BASIC_RATE_MASK;
		if (rate > user_rate)
			continue;
		if (ieee80211softmac_ratesinfo_rate_supported(&mac->ratesinfo, rate))
			return rate;
	}

	/* If we haven't found a suitable rate by now, just trust the user */
	return user_rate;
}
EXPORT_SYMBOL_GPL(ieee80211softmac_highest_supported_rate);

void ieee80211softmac_process_erp(struct ieee80211softmac_device *mac,
	u8 erp_value)
{
	int use_protection;
	int short_preamble;
	u32 changes = 0;

	/* Barker preamble mode */
	short_preamble = ((erp_value & WLAN_ERP_BARKER_PREAMBLE) == 0
			  && mac->associnfo.short_preamble_available) ? 1 : 0;

	/* Protection needed? */
	use_protection = (erp_value & WLAN_ERP_USE_PROTECTION) != 0;

	if (mac->bssinfo.short_preamble != short_preamble) {
		changes |= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;
		mac->bssinfo.short_preamble = short_preamble;
	}

	if (mac->bssinfo.use_protection != use_protection) {
		changes |= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;
		mac->bssinfo.use_protection = use_protection;
	}

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

void ieee80211softmac_recalc_txrates(struct ieee80211softmac_device *mac)
{
	struct ieee80211softmac_txrates *txrates = &mac->txrates;
	u32 change = 0;

	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	txrates->default_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 0);

	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	txrates->default_fallback = lower_rate(mac, txrates->default_rate);

	change |= IEEE80211SOFTMAC_TXRATECHG_MCAST;
	txrates->mcast_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 1);

	if (mac->txrates_change)
		mac->txrates_change(mac->dev, change);

}

void ieee80211softmac_init_bss(struct ieee80211softmac_device *mac)
{
	struct ieee80211_device *ieee = mac->ieee;
	u32 change = 0;
	struct ieee80211softmac_txrates *txrates = &mac->txrates;
	struct ieee80211softmac_bss_info *bssinfo = &mac->bssinfo;

	/* 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 (ieee->modulation & IEEE80211_OFDM_MODULATION)
		txrates->user_rate = IEEE80211_OFDM_RATE_24MB;
	else
		txrates->user_rate = IEEE80211_CCK_RATE_11MB;

	txrates->default_rate = IEEE80211_CCK_RATE_1MB;
	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;

	txrates->default_fallback = IEEE80211_CCK_RATE_1MB;
	change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;

	txrates->mcast_rate = IEEE80211_CCK_RATE_1MB;
	change |= IEEE80211SOFTMAC_TXRATECHG_MCAST;

	txrates->mgt_mcast_rate = IEEE80211_CCK_RATE_1MB;
	change |= IEEE80211SOFTMAC_TXRATECHG_MGT_MCAST;

	if (mac->txrates_change)
		mac->txrates_change(mac->dev, change);

	change = 0;

	bssinfo->supported_rates.count = 0;
	memset(bssinfo->supported_rates.rates, 0,
		sizeof(bssinfo->supported_rates.rates));
	change |= IEEE80211SOFTMAC_BSSINFOCHG_RATES;

	bssinfo->short_preamble = 0;
	change |= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;

	bssinfo->use_protection = 0;
	change |= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;

	if (mac->bssinfo_change)
		mac->bssinfo_change(mac->dev, change);

	mac->running = 1;
}

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

	ieee80211softmac_start_check_rates(mac);
	ieee80211softmac_init_bss(mac);
}
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)
{
	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. */
		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. */
		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);
}

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

	/* we save the ERP value because it is needed at association time, and
	 * many AP's do not include an ERP IE in the association response. */
	softnet->erp_value = net->erp_value;

	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 ieee80211softmac_network *softmac_net;

	list_for_each_entry(softmac_net, &mac->network_list, list) {
		if(!memcmp(softmac_net->bssid, add_net->bssid, ETH_ALEN))
			return;
	}
	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 ieee80211softmac_network *softmac_net;

	list_for_each_entry(softmac_net, &mac->network_list, list) {
		if(!memcmp(softmac_net->bssid, bssid, ETH_ALEN))
			return softmac_net;
	}
	return NULL;
}

/* 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 ieee80211softmac_network *softmac_net;

	list_for_each_entry(softmac_net, &mac->network_list, 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"
370121e5 JB	28	#include <linux/sort.h>
8462fe3c	29	#include <linux/etherdevice.h>
370121e5 JB	30
	31	struct net_device *alloc_ieee80211softmac(int sizeof_priv)
	32	{
	33	struct ieee80211softmac_device *softmac;
	34	struct net_device *dev;
64265651	35
ef7ab235 AM	36	dev = alloc_ieee80211(sizeof(*softmac) + sizeof_priv);
	37	if (!dev)
	38	return NULL;
	39
370121e5 JB	40	softmac = ieee80211_priv(dev);
	41	softmac->dev = dev;
	42	softmac->ieee = netdev_priv(dev);
	43	spin_lock_init(&softmac->lock);
64265651	44
370121e5 JB	45	softmac->ieee->handle_auth = ieee80211softmac_auth_resp;
	46	softmac->ieee->handle_deauth = ieee80211softmac_deauth_resp;
	47	softmac->ieee->handle_assoc_response = ieee80211softmac_handle_assoc_response;
b6c7658e	48	softmac->ieee->handle_reassoc_request = ieee80211softmac_handle_reassoc_req;
370121e5	49	softmac->ieee->handle_disassoc = ieee80211softmac_handle_disassoc;
64265651	50	softmac->ieee->handle_beacon = ieee80211softmac_handle_beacon;
370121e5 JB	51	softmac->scaninfo = NULL;
370121e5 JB	52
818667f7 JB	53	softmac->associnfo.scan_retry = IEEE80211SOFTMAC_ASSOC_SCAN_RETRY_LIMIT;
818667f7 JB	54
370121e5 JB	55	/* TODO: initialise all the other callbacks in the ieee struct
	56	* (once they're written)
	57	*/
	58
370121e5 JB	59	INIT_LIST_HEAD(&softmac->auth_queue);
	60	INIT_LIST_HEAD(&softmac->network_list);
	61	INIT_LIST_HEAD(&softmac->events);
	62
7c28ad2d	63	mutex_init(&softmac->associnfo.mutex);
c4028958 DH	64	INIT_DELAYED_WORK(&softmac->associnfo.work, ieee80211softmac_assoc_work);
c4028958 DH	65	INIT_DELAYED_WORK(&softmac->associnfo.timeout, ieee80211softmac_assoc_timeout);
370121e5 JB	66	softmac->start_scan = ieee80211softmac_start_scan_implementation;
	67	softmac->wait_for_scan = ieee80211softmac_wait_for_scan_implementation;
	68	softmac->stop_scan = ieee80211softmac_stop_scan_implementation;
	69
2dd50801 JB	70	/* to start with, we can't send anything ... */
2dd50801 JB	71	netif_carrier_off(dev);
64265651	72
370121e5	73	return dev;
370121e5	74	}
4c718cfd	75	EXPORT_SYMBOL_GPL(alloc_ieee80211softmac);
370121e5 JB	76
370121e5 JB	77	/* Clears the pending work queue items, stops all scans, etc. */
64265651	78	void
370121e5 JB	79	ieee80211softmac_clear_pending_work(struct ieee80211softmac_device *sm)
	80	{
	81	unsigned long flags;
	82	struct ieee80211softmac_event eventptr, eventtmp;
	83	struct ieee80211softmac_auth_queue_item authptr, authtmp;
	84	struct ieee80211softmac_network netptr, nettmp;
64265651	85
370121e5 JB	86	ieee80211softmac_stop_scan(sm);
370121e5 JB	87	ieee80211softmac_wait_for_scan(sm);
64265651	88
370121e5	89	spin_lock_irqsave(&sm->lock, flags);
d57336e3 DD	90	sm->running = 0;
d57336e3 DD	91
370121e5 JB	92	/* Free all pending assoc work items */
370121e5 JB	93	cancel_delayed_work(&sm->associnfo.work);
64265651	94
370121e5 JB	95	/* Free all pending scan work items */
370121e5 JB	96	if(sm->scaninfo != NULL)
64265651 YH	97	cancel_delayed_work(&sm->scaninfo->softmac_scan);
64265651 YH	98
370121e5 JB	99	/* Free all pending auth work items */
	100	list_for_each_entry(authptr, &sm->auth_queue, list)
	101	cancel_delayed_work(&authptr->work);
64265651	102
370121e5 JB	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	}
64265651	117
370121e5 JB	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	}
64265651	123
370121e5 JB	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);
64265651	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
8462fe3c DD	171	int ieee80211softmac_ratesinfo_rate_supported(struct ieee80211softmac_ratesinfo *ri, u8 rate)
	172	{
	173	int search;
	174	u8 search_rate;
	175
	176	for (search = 0; search < ri->count; search++) {
	177	search_rate = ri->rates[search];
	178	search_rate &= ~IEEE80211_BASIC_RATE_MASK;
	179	if (rate == search_rate)
	180	return 1;
	181	}
	182
	183	return 0;
	184	}
	185
d7712ac2	186	u8 ieee80211softmac_highest_supported_rate(struct ieee80211softmac_device *mac,
8462fe3c DD	187	struct ieee80211softmac_ratesinfo *ri, int basic_only)
	188	{
	189	u8 user_rate = mac->txrates.user_rate;
	190	int i;
	191
d7712ac2	192	if (ri->count == 0)
8462fe3c	193	return IEEE80211_CCK_RATE_1MB;
8462fe3c DD	194
	195	for (i = ri->count - 1; i >= 0; i--) {
	196	u8 rate = ri->rates[i];
	197	if (basic_only && !(rate & IEEE80211_BASIC_RATE_MASK))
	198	continue;
	199	rate &= ~IEEE80211_BASIC_RATE_MASK;
	200	if (rate > user_rate)
	201	continue;
	202	if (ieee80211softmac_ratesinfo_rate_supported(&mac->ratesinfo, rate))
	203	return rate;
	204	}
	205
	206	/* If we haven't found a suitable rate by now, just trust the user */
	207	return user_rate;
	208	}
d7712ac2	209	EXPORT_SYMBOL_GPL(ieee80211softmac_highest_supported_rate);
8462fe3c	210
5acd0c41 DD	211	void ieee80211softmac_process_erp(struct ieee80211softmac_device *mac,
	212	u8 erp_value)
	213	{
64265651	214	int use_protection;
5acd0c41	215	int short_preamble;
64265651	216	u32 changes = 0;
5acd0c41 DD	217
	218	/* Barker preamble mode */
	219	short_preamble = ((erp_value & WLAN_ERP_BARKER_PREAMBLE) == 0
	220	&& mac->associnfo.short_preamble_available) ? 1 : 0;
	221
	222	/* Protection needed? */
	223	use_protection = (erp_value & WLAN_ERP_USE_PROTECTION) != 0;
	224
	225	if (mac->bssinfo.short_preamble != short_preamble) {
	226	changes \|= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;
	227	mac->bssinfo.short_preamble = short_preamble;
	228	}
	229
	230	if (mac->bssinfo.use_protection != use_protection) {
	231	changes \|= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;
	232	mac->bssinfo.use_protection = use_protection;
	233	}
	234
	235	if (mac->bssinfo_change && changes)
	236	mac->bssinfo_change(mac->dev, changes);
	237	}
	238
8462fe3c DD	239	void ieee80211softmac_recalc_txrates(struct ieee80211softmac_device *mac)
	240	{
	241	struct ieee80211softmac_txrates *txrates = &mac->txrates;
8462fe3c DD	242	u32 change = 0;
8462fe3c DD	243
8462fe3c	244	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
d7712ac2	245	txrates->default_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 0);
8462fe3c DD	246
	247	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	248	txrates->default_fallback = lower_rate(mac, txrates->default_rate);
	249
	250	change \|= IEEE80211SOFTMAC_TXRATECHG_MCAST;
d7712ac2	251	txrates->mcast_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 1);
8462fe3c DD	252
8462fe3c DD	253	if (mac->txrates_change)
5acd0c41	254	mac->txrates_change(mac->dev, change);
8462fe3c DD	255
	256	}
	257
5acd0c41	258	void ieee80211softmac_init_bss(struct ieee80211softmac_device *mac)
370121e5	259	{
370121e5 JB	260	struct ieee80211_device *ieee = mac->ieee;
370121e5 JB	261	u32 change = 0;
8462fe3c	262	struct ieee80211softmac_txrates *txrates = &mac->txrates;
5acd0c41	263	struct ieee80211softmac_bss_info *bssinfo = &mac->bssinfo;
370121e5	264
370121e5 JB	265	/* TODO: We need some kind of state machine to lower the default rates
	266	* if we loose too many packets.
	267	*/
	268	/* Change the default txrate to the highest possible value.
	269	* The txrate machine will lower it, if it is too high.
	270	*/
bb52a653 LF	271	if (ieee->modulation & IEEE80211_OFDM_MODULATION)
	272	txrates->user_rate = IEEE80211_OFDM_RATE_24MB;
	273	else
8462fe3c	274	txrates->user_rate = IEEE80211_CCK_RATE_11MB;
8462fe3c DD	275
	276	txrates->default_rate = IEEE80211_CCK_RATE_1MB;
	277	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	278
	279	txrates->default_fallback = IEEE80211_CCK_RATE_1MB;
	280	change \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	281
	282	txrates->mcast_rate = IEEE80211_CCK_RATE_1MB;
	283	change \|= IEEE80211SOFTMAC_TXRATECHG_MCAST;
	284
	285	txrates->mgt_mcast_rate = IEEE80211_CCK_RATE_1MB;
	286	change \|= IEEE80211SOFTMAC_TXRATECHG_MGT_MCAST;
	287
370121e5	288	if (mac->txrates_change)
5acd0c41 DD	289	mac->txrates_change(mac->dev, change);
	290
	291	change = 0;
	292
	293	bssinfo->supported_rates.count = 0;
	294	memset(bssinfo->supported_rates.rates, 0,
	295	sizeof(bssinfo->supported_rates.rates));
	296	change \|= IEEE80211SOFTMAC_BSSINFOCHG_RATES;
	297
	298	bssinfo->short_preamble = 0;
	299	change \|= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;
	300
	301	bssinfo->use_protection = 0;
	302	change \|= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;
	303
	304	if (mac->bssinfo_change)
	305	mac->bssinfo_change(mac->dev, change);
d57336e3 DD	306
d57336e3 DD	307	mac->running = 1;
370121e5	308	}
8462fe3c DD	309
	310	void ieee80211softmac_start(struct net_device *dev)
	311	{
	312	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	313
	314	ieee80211softmac_start_check_rates(mac);
5acd0c41	315	ieee80211softmac_init_bss(mac);
8462fe3c	316	}
4c718cfd	317	EXPORT_SYMBOL_GPL(ieee80211softmac_start);
370121e5 JB	318
	319	void ieee80211softmac_stop(struct net_device *dev)
	320	{
	321	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	322
	323	ieee80211softmac_clear_pending_work(mac);
	324	}
4c718cfd	325	EXPORT_SYMBOL_GPL(ieee80211softmac_stop);
370121e5 JB	326
	327	void ieee80211softmac_set_rates(struct net_device dev, u8 count, u8 rates)
	328	{
	329	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	330	unsigned long flags;
64265651	331
370121e5 JB	332	spin_lock_irqsave(&mac->lock, flags);
	333	memcpy(mac->ratesinfo.rates, rates, count);
	334	mac->ratesinfo.count = count;
	335	spin_unlock_irqrestore(&mac->lock, flags);
	336	}
4c718cfd	337	EXPORT_SYMBOL_GPL(ieee80211softmac_set_rates);
370121e5 JB	338
	339	static u8 raise_rate(struct ieee80211softmac_device *mac, u8 rate)
	340	{
	341	int i;
	342	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
64265651	343
370121e5 JB	344	for (i=0; i<ri->count-1; i++) {
	345	if (ri->rates[i] == rate)
	346	return ri->rates[i+1];
	347	}
	348	/* I guess we can't go any higher... */
	349	return ri->rates[ri->count];
	350	}
	351
	352	u8 ieee80211softmac_lower_rate_delta(struct ieee80211softmac_device *mac, u8 rate, int delta)
	353	{
	354	int i;
	355	struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
64265651	356
370121e5 JB	357	for (i=delta; i<ri->count; i++) {
	358	if (ri->rates[i] == rate)
	359	return ri->rates[i-delta];
	360	}
	361	/* I guess we can't go any lower... */
	362	return ri->rates[0];
	363	}
	364
	365	static void ieee80211softmac_add_txrates_badness(struct ieee80211softmac_device *mac,
	366	int amount)
	367	{
370121e5 JB	368	u8 default_rate = mac->txrates.default_rate;
	369	u8 default_fallback = mac->txrates.default_fallback;
	370	u32 changes = 0;
	371
	372	//TODO: This is highly experimental code.
	373	// Maybe the dynamic rate selection does not work
	374	// and it has to be removed again.
	375
	376	printk("badness %d\n", mac->txrate_badness);
	377	mac->txrate_badness += amount;
	378	if (mac->txrate_badness <= -1000) {
	379	/* Very small badness. Try a faster bitrate. */
370121e5 JB	380	default_rate = raise_rate(mac, default_rate);
	381	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	382	default_fallback = get_fallback_rate(mac, default_rate);
	383	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	384	mac->txrate_badness = 0;
	385	printk("Bitrate raised to %u\n", default_rate);
	386	} else if (mac->txrate_badness >= 10000) {
	387	/* Very high badness. Try a slower bitrate. */
370121e5 JB	388	default_rate = lower_rate(mac, default_rate);
	389	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
	390	default_fallback = get_fallback_rate(mac, default_rate);
	391	changes \|= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
	392	mac->txrate_badness = 0;
	393	printk("Bitrate lowered to %u\n", default_rate);
	394	}
	395
	396	mac->txrates.default_rate = default_rate;
	397	mac->txrates.default_fallback = default_fallback;
	398
	399	if (changes && mac->txrates_change)
5acd0c41	400	mac->txrates_change(mac->dev, changes);
370121e5 JB	401	}
	402
	403	void ieee80211softmac_fragment_lost(struct net_device *dev,
	404	u16 wl_seq)
	405	{
	406	struct ieee80211softmac_device *mac = ieee80211_priv(dev);
	407	unsigned long flags;
	408
	409	spin_lock_irqsave(&mac->lock, flags);
	410	ieee80211softmac_add_txrates_badness(mac, 1000);
	411	//TODO
	412
	413	spin_unlock_irqrestore(&mac->lock, flags);
	414	}
4c718cfd	415	EXPORT_SYMBOL_GPL(ieee80211softmac_fragment_lost);
370121e5 JB	416
	417	static int rate_cmp(const void a_, const void b_) {
	418	u8 a, b;
	419	a = (u8*)a_;
	420	b = (u8*)b_;
	421	return ((a & ~IEEE80211_BASIC_RATE_MASK) - (b & ~IEEE80211_BASIC_RATE_MASK));
	422	}
	423
	424	/* Allocate a softmac network struct and fill it from a network */
	425	struct ieee80211softmac_network *
	426	ieee80211softmac_create_network(struct ieee80211softmac_device *mac,
	427	struct ieee80211_network *net)
	428	{
	429	struct ieee80211softmac_network *softnet;
	430	softnet = kzalloc(sizeof(struct ieee80211softmac_network), GFP_ATOMIC);
	431	if(softnet == NULL)
	432	return NULL;
	433	memcpy(softnet->bssid, net->bssid, ETH_ALEN);
	434	softnet->channel = net->channel;
	435	softnet->essid.len = net->ssid_len;
	436	memcpy(softnet->essid.data, net->ssid, softnet->essid.len);
64265651	437
370121e5 JB	438	/* copy rates over */
	439	softnet->supported_rates.count = net->rates_len;
	440	memcpy(&softnet->supported_rates.rates[0], net->rates, net->rates_len);
	441	memcpy(&softnet->supported_rates.rates[softnet->supported_rates.count], net->rates_ex, net->rates_ex_len);
	442	softnet->supported_rates.count += net->rates_ex_len;
	443	sort(softnet->supported_rates.rates, softnet->supported_rates.count, sizeof(softnet->supported_rates.rates[0]), rate_cmp, NULL);
5acd0c41 DD	444
	445	/* we save the ERP value because it is needed at association time, and
	446	* many AP's do not include an ERP IE in the association response. */
	447	softnet->erp_value = net->erp_value;
	448
370121e5 JB	449	softnet->capabilities = net->capability;
	450	return softnet;
	451	}
	452
	453
	454	/* Add a network to the list, while locked */
	455	void
	456	ieee80211softmac_add_network_locked(struct ieee80211softmac_device *mac,
	457	struct ieee80211softmac_network *add_net)
	458	{
67c4f7aa	459	struct ieee80211softmac_network *softmac_net;
370121e5	460
67c4f7aa	461	list_for_each_entry(softmac_net, &mac->network_list, list) {
370121e5	462	if(!memcmp(softmac_net->bssid, add_net->bssid, ETH_ALEN))
67c4f7aa	463	return;
370121e5	464	}
67c4f7aa	465	list_add(&(add_net->list), &mac->network_list);
370121e5 JB	466	}
	467
	468	/* Add a network to the list, with locking */
	469	void
	470	ieee80211softmac_add_network(struct ieee80211softmac_device *mac,
	471	struct ieee80211softmac_network *add_net)
	472	{
	473	unsigned long flags;
	474	spin_lock_irqsave(&mac->lock, flags);
	475	ieee80211softmac_add_network_locked(mac, add_net);
	476	spin_unlock_irqrestore(&mac->lock, flags);
	477	}
	478
	479
	480	/* Delete a network from the list, while locked*/
	481	void
	482	ieee80211softmac_del_network_locked(struct ieee80211softmac_device *mac,
	483	struct ieee80211softmac_network *del_net)
	484	{
	485	list_del(&(del_net->list));
	486	}
	487
	488	/* Delete a network from the list with locking */
	489	void
	490	ieee80211softmac_del_network(struct ieee80211softmac_device *mac,
	491	struct ieee80211softmac_network *del_net)
	492	{
	493	unsigned long flags;
	494	spin_lock_irqsave(&mac->lock, flags);
	495	ieee80211softmac_del_network_locked(mac, del_net);
	496	spin_unlock_irqrestore(&mac->lock, flags);
	497	}
	498
	499	/* Get a network from the list by MAC while locked */
	500	struct ieee80211softmac_network *
	501	ieee80211softmac_get_network_by_bssid_locked(struct ieee80211softmac_device *mac,
	502	u8 *bssid)
	503	{
67c4f7aa AM	504	struct ieee80211softmac_network *softmac_net;
	505
	506	list_for_each_entry(softmac_net, &mac->network_list, list) {
370121e5	507	if(!memcmp(softmac_net->bssid, bssid, ETH_ALEN))
67c4f7aa	508	return softmac_net;
370121e5	509	}
67c4f7aa	510	return NULL;
370121e5 JB	511	}
	512
	513	/* Get a network from the list by BSSID with locking */
	514	struct ieee80211softmac_network *
	515	ieee80211softmac_get_network_by_bssid(struct ieee80211softmac_device *mac,
	516	u8 *bssid)
	517	{
	518	unsigned long flags;
	519	struct ieee80211softmac_network *softmac_net;
64265651	520
370121e5 JB	521	spin_lock_irqsave(&mac->lock, flags);
	522	softmac_net = ieee80211softmac_get_network_by_bssid_locked(mac, bssid);
	523	spin_unlock_irqrestore(&mac->lock, flags);
	524	return softmac_net;
	525	}
	526
	527	/* Get a network from the list by ESSID while locked */
	528	struct ieee80211softmac_network *
	529	ieee80211softmac_get_network_by_essid_locked(struct ieee80211softmac_device *mac,
	530	struct ieee80211softmac_essid *essid)
	531	{
67c4f7aa	532	struct ieee80211softmac_network *softmac_net;
370121e5	533
67c4f7aa	534	list_for_each_entry(softmac_net, &mac->network_list, list) {
370121e5 JB	535	if (softmac_net->essid.len == essid->len &&
	536	!memcmp(softmac_net->essid.data, essid->data, essid->len))
	537	return softmac_net;
	538	}
	539	return NULL;
	540	}
	541
	542	/* Get a network from the list by ESSID with locking */
	543	struct ieee80211softmac_network *
	544	ieee80211softmac_get_network_by_essid(struct ieee80211softmac_device *mac,
64265651	545	struct ieee80211softmac_essid *essid)
370121e5 JB	546	{
	547	unsigned long flags;
	548	struct ieee80211softmac_network *softmac_net = NULL;
	549
	550	spin_lock_irqsave(&mac->lock, flags);
64265651	551	softmac_net = ieee80211softmac_get_network_by_essid_locked(mac, essid);
370121e5 JB	552	spin_unlock_irqrestore(&mac->lock, flags);
	553	return softmac_net;
	554	}
	555
	556	MODULE_LICENSE("GPL");
9ebdd466 JB	557	MODULE_AUTHOR("Johannes Berg");
	558	MODULE_AUTHOR("Joseph Jezak");
	559	MODULE_AUTHOR("Larry Finger");
	560	MODULE_AUTHOR("Danny van Dyk");
	561	MODULE_AUTHOR("Michael Buesch");
	562	MODULE_DESCRIPTION("802.11 software MAC");