[net-next-2.6.git] / drivers / staging / rtl8192u / ieee80211 / ieee80211_module.c

/*******************************************************************************

  Copyright(c) 2004 Intel Corporation. All rights reserved.

  Portions of this file are based on the WEP enablement code provided by the
  Host AP project hostap-drivers v0.1.3
  Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
  <jkmaline@cc.hut.fi>
  Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>

  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., 59
  Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  The full GNU General Public License is included in this distribution in the
  file called LICENSE.

  Contact Information:
  James P. Ketrenos <ipw2100-admin@linux.intel.com>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

#include <linux/compiler.h>
//#include <linux/config.h>
#include <linux/errno.h>
#include <linux/if_arp.h>
#include <linux/in6.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/pci.h>
#include <linux/proc_fs.h>
#include <linux/skbuff.h>
#include <linux/slab.h>
#include <linux/tcp.h>
#include <linux/types.h>
#include <linux/version.h>
#include <linux/wireless.h>
#include <linux/etherdevice.h>
#include <asm/uaccess.h>
#include <net/arp.h>

#include "ieee80211.h"

MODULE_DESCRIPTION("802.11 data/management/control stack");
MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
MODULE_LICENSE("GPL");

#define DRV_NAME "ieee80211"

static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
{
	if (ieee->networks)
		return 0;

	ieee->networks = kcalloc(
		MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
		GFP_KERNEL);
	if (!ieee->networks) {
		printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
		       ieee->dev->name);
		return -ENOMEM;
	}

	return 0;
}

static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
{
	if (!ieee->networks)
		return;
	kfree(ieee->networks);
	ieee->networks = NULL;
}

static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
{
	int i;

	INIT_LIST_HEAD(&ieee->network_free_list);
	INIT_LIST_HEAD(&ieee->network_list);
	for (i = 0; i < MAX_NETWORK_COUNT; i++)
		list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
}


struct net_device *alloc_ieee80211(int sizeof_priv)
{
	struct ieee80211_device *ieee;
	struct net_device *dev;
	int i,err;

	IEEE80211_DEBUG_INFO("Initializing...\n");

	dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
	if (!dev) {
		IEEE80211_ERROR("Unable to network device.\n");
		goto failed;
	}

	ieee = netdev_priv(dev);
	memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv);
	ieee->dev = dev;

	err = ieee80211_networks_allocate(ieee);
	if (err) {
		IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
				err);
		goto failed;
	}
	ieee80211_networks_initialize(ieee);


	/* Default fragmentation threshold is maximum payload size */
	ieee->fts = DEFAULT_FTS;
	ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
	ieee->open_wep = 1;

	/* Default to enabling full open WEP with host based encrypt/decrypt */
	ieee->host_encrypt = 1;
	ieee->host_decrypt = 1;
	ieee->ieee802_1x = 1; /* Default to supporting 802.1x */

	INIT_LIST_HEAD(&ieee->crypt_deinit_list);
	init_timer(&ieee->crypt_deinit_timer);
	ieee->crypt_deinit_timer.data = (unsigned long)ieee;
	ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;

	spin_lock_init(&ieee->lock);
	spin_lock_init(&ieee->wpax_suitlist_lock);
	spin_lock_init(&ieee->bw_spinlock);
	spin_lock_init(&ieee->reorder_spinlock);
	//added by WB
	atomic_set(&(ieee->atm_chnlop), 0);
	atomic_set(&(ieee->atm_swbw), 0);

	ieee->wpax_type_set = 0;
	ieee->wpa_enabled = 0;
	ieee->tkip_countermeasures = 0;
	ieee->drop_unencrypted = 0;
	ieee->privacy_invoked = 0;
	ieee->ieee802_1x = 1;
	ieee->raw_tx = 0;
	//ieee->hwsec_support = 1; //defalt support hw security. //use module_param instead.
	ieee->hwsec_active = 0; //disable hwsec, switch it on when necessary.

	ieee80211_softmac_init(ieee);

	ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
	if (ieee->pHTInfo == NULL)
	{
		IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
		return NULL;
	}
	HTUpdateDefaultSetting(ieee);
	HTInitializeHTInfo(ieee); //may move to other place.
	TSInitialize(ieee);

	for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
		INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);

	for (i = 0; i < 17; i++) {
	  ieee->last_rxseq_num[i] = -1;
	  ieee->last_rxfrag_num[i] = -1;
	  ieee->last_packet_time[i] = 0;
	}

//These function were added to load crypte module autoly
	ieee80211_tkip_null();
	ieee80211_wep_null();
	ieee80211_ccmp_null();

	return dev;

 failed:
	if (dev)
		free_netdev(dev);

	return NULL;
}


void free_ieee80211(struct net_device *dev)
{
	struct ieee80211_device *ieee = netdev_priv(dev);
	int i;
	//struct list_head *p, *q;
//	del_timer_sync(&ieee->SwBwTimer);
	if (ieee->pHTInfo != NULL)
	{
		kfree(ieee->pHTInfo);
		ieee->pHTInfo = NULL;
	}
	RemoveAllTS(ieee);
	ieee80211_softmac_free(ieee);
	del_timer_sync(&ieee->crypt_deinit_timer);
	ieee80211_crypt_deinit_entries(ieee, 1);

	for (i = 0; i < WEP_KEYS; i++) {
		struct ieee80211_crypt_data *crypt = ieee->crypt[i];
		if (crypt) {
			if (crypt->ops)
				crypt->ops->deinit(crypt->priv);
			kfree(crypt);
			ieee->crypt[i] = NULL;
		}
	}

	ieee80211_networks_free(ieee);
	free_netdev(dev);
}

#ifdef CONFIG_IEEE80211_DEBUG

u32 ieee80211_debug_level = 0;
static int debug = \
	//		    IEEE80211_DL_INFO	|
	//		    IEEE80211_DL_WX	|
	//		    IEEE80211_DL_SCAN	|
	//		    IEEE80211_DL_STATE	|
	//		    IEEE80211_DL_MGMT	|
	//		    IEEE80211_DL_FRAG	|
	//		    IEEE80211_DL_EAP	|
	//		    IEEE80211_DL_DROP	|
	//		    IEEE80211_DL_TX	|
	//		    IEEE80211_DL_RX	|
			    //IEEE80211_DL_QOS    |
	//		    IEEE80211_DL_HT 	|
	//		    IEEE80211_DL_TS	|
//			    IEEE80211_DL_BA 	|
	//		    IEEE80211_DL_REORDER|
//			    IEEE80211_DL_TRACE  |
			    //IEEE80211_DL_DATA	|
			    IEEE80211_DL_ERR	  //awayls open this flags to show error out
			    ;
struct proc_dir_entry *ieee80211_proc = NULL;

static int show_debug_level(char *page, char **start, off_t offset,
			    int count, int *eof, void *data)
{
	return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
}

static int store_debug_level(struct file *file, const char *buffer,
			     unsigned long count, void *data)
{
	char buf[] = "0x00000000";
	unsigned long len = min_t(unsigned long, sizeof(buf) - 1, count);
	char *p = (char *)buf;
	unsigned long val;

	if (copy_from_user(buf, buffer, len))
		return count;
	buf[len] = 0;
	if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
		p++;
		if (p[0] == 'x' || p[0] == 'X')
			p++;
		val = simple_strtoul(p, &p, 16);
	} else
		val = simple_strtoul(p, &p, 10);
	if (p == buf)
		printk(KERN_INFO DRV_NAME
		       ": %s is not in hex or decimal form.\n", buf);
	else
		ieee80211_debug_level = val;

	return strnlen(buf, count);
}

int __init ieee80211_debug_init(void)
{
	struct proc_dir_entry *e;

	ieee80211_debug_level = debug;

	ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
	if (ieee80211_proc == NULL) {
		IEEE80211_ERROR("Unable to create " DRV_NAME
				" proc directory\n");
		return -EIO;
	}
	e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
			      ieee80211_proc);
	if (!e) {
		remove_proc_entry(DRV_NAME, init_net.proc_net);
		ieee80211_proc = NULL;
		return -EIO;
	}
	e->read_proc = show_debug_level;
	e->write_proc = store_debug_level;
	e->data = NULL;

	return 0;
}

void __exit ieee80211_debug_exit(void)
{
	if (ieee80211_proc) {
		remove_proc_entry("debug_level", ieee80211_proc);
		remove_proc_entry(DRV_NAME, init_net.proc_net);
		ieee80211_proc = NULL;
	}
}

#include <linux/moduleparam.h>
module_param(debug, int, 0444);
MODULE_PARM_DESC(debug, "debug output mask");
#endif
Commit	Line	Data
8fc8598e JC	1	/*******************************************************************************
	2
	3	Copyright(c) 2004 Intel Corporation. All rights reserved.
	4
	5	Portions of this file are based on the WEP enablement code provided by the
	6	Host AP project hostap-drivers v0.1.3
	7	Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
	8	<jkmaline@cc.hut.fi>
	9	Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
	10
	11	This program is free software; you can redistribute it and/or modify it
	12	under the terms of version 2 of the GNU General Public License as
	13	published by the Free Software Foundation.
	14
	15	This program is distributed in the hope that it will be useful, but WITHOUT
	16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	17	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	18	more details.
	19
	20	You should have received a copy of the GNU General Public License along with
	21	this program; if not, write to the Free Software Foundation, Inc., 59
	22	Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	23
	24	The full GNU General Public License is included in this distribution in the
	25	file called LICENSE.
	26
	27	Contact Information:
	28	James P. Ketrenos <ipw2100-admin@linux.intel.com>
	29	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	30
	31	*******************************************************************************/
	32
	33	#include <linux/compiler.h>
	34	//#include <linux/config.h>
	35	#include <linux/errno.h>
	36	#include <linux/if_arp.h>
	37	#include <linux/in6.h>
	38	#include <linux/in.h>
	39	#include <linux/ip.h>
	40	#include <linux/kernel.h>
	41	#include <linux/module.h>
	42	#include <linux/netdevice.h>
	43	#include <linux/pci.h>
	44	#include <linux/proc_fs.h>
	45	#include <linux/skbuff.h>
	46	#include <linux/slab.h>
	47	#include <linux/tcp.h>
	48	#include <linux/types.h>
	49	#include <linux/version.h>
	50	#include <linux/wireless.h>
	51	#include <linux/etherdevice.h>
	52	#include <asm/uaccess.h>
	53	#include <net/arp.h>
	54
	55	#include "ieee80211.h"
	56
	57	MODULE_DESCRIPTION("802.11 data/management/control stack");
	58	MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
	59	MODULE_LICENSE("GPL");
	60
	61	#define DRV_NAME "ieee80211"
	62
	63	static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
	64	{
65	if (ieee->networks)
66	return 0;
67
7a6cb0d5 JL	68	ieee->networks = kcalloc(
7a6cb0d5 JL	69	MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
8fc8598e JC	70	GFP_KERNEL);
	71	if (!ieee->networks) {
	72	printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
	73	ieee->dev->name);
	74	return -ENOMEM;
	75	}
	76
8fc8598e JC	77	return 0;
	78	}
	79
	80	static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
	81	{
	82	if (!ieee->networks)
	83	return;
	84	kfree(ieee->networks);
	85	ieee->networks = NULL;
	86	}
	87
	88	static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
	89	{
	90	int i;
	91
	92	INIT_LIST_HEAD(&ieee->network_free_list);
	93	INIT_LIST_HEAD(&ieee->network_list);
	94	for (i = 0; i < MAX_NETWORK_COUNT; i++)
	95	list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
	96	}
	97
	98
	99	struct net_device *alloc_ieee80211(int sizeof_priv)
	100	{
	101	struct ieee80211_device *ieee;
	102	struct net_device *dev;
	103	int i,err;
	104
	105	IEEE80211_DEBUG_INFO("Initializing...\n");
	106
	107	dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
	108	if (!dev) {
	109	IEEE80211_ERROR("Unable to network device.\n");
	110	goto failed;
	111	}
	112
8fc8598e	113	ieee = netdev_priv(dev);
8fc8598e JC	114	memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv);
	115	ieee->dev = dev;
	116
	117	err = ieee80211_networks_allocate(ieee);
	118	if (err) {
	119	IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
	120	err);
	121	goto failed;
	122	}
	123	ieee80211_networks_initialize(ieee);
	124
	125
	126	/* Default fragmentation threshold is maximum payload size */
	127	ieee->fts = DEFAULT_FTS;
	128	ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
	129	ieee->open_wep = 1;
	130
	131	/* Default to enabling full open WEP with host based encrypt/decrypt */
	132	ieee->host_encrypt = 1;
	133	ieee->host_decrypt = 1;
	134	ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
	135
	136	INIT_LIST_HEAD(&ieee->crypt_deinit_list);
	137	init_timer(&ieee->crypt_deinit_timer);
	138	ieee->crypt_deinit_timer.data = (unsigned long)ieee;
	139	ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
	140
	141	spin_lock_init(&ieee->lock);
	142	spin_lock_init(&ieee->wpax_suitlist_lock);
	143	spin_lock_init(&ieee->bw_spinlock);
	144	spin_lock_init(&ieee->reorder_spinlock);
	145	//added by WB
	146	atomic_set(&(ieee->atm_chnlop), 0);
	147	atomic_set(&(ieee->atm_swbw), 0);
	148
	149	ieee->wpax_type_set = 0;
e406322b MCC	150	ieee->wpa_enabled = 0;
	151	ieee->tkip_countermeasures = 0;
	152	ieee->drop_unencrypted = 0;
	153	ieee->privacy_invoked = 0;
	154	ieee->ieee802_1x = 1;
8fc8598e JC	155	ieee->raw_tx = 0;
	156	//ieee->hwsec_support = 1; //defalt support hw security. //use module_param instead.
	157	ieee->hwsec_active = 0; //disable hwsec, switch it on when necessary.
	158
	159	ieee80211_softmac_init(ieee);
	160
32414878	161	ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
8fc8598e JC	162	if (ieee->pHTInfo == NULL)
	163	{
	164	IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
	165	return NULL;
	166	}
	167	HTUpdateDefaultSetting(ieee);
	168	HTInitializeHTInfo(ieee); //may move to other place.
	169	TSInitialize(ieee);
f61fb935	170
8fc8598e JC	171	for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
	172	INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
	173
	174	for (i = 0; i < 17; i++) {
	175	ieee->last_rxseq_num[i] = -1;
	176	ieee->last_rxfrag_num[i] = -1;
	177	ieee->last_packet_time[i] = 0;
	178	}
	179
	180	//These function were added to load crypte module autoly
	181	ieee80211_tkip_null();
	182	ieee80211_wep_null();
	183	ieee80211_ccmp_null();
	184
	185	return dev;
	186
	187	failed:
	188	if (dev)
8fc8598e	189	free_netdev(dev);
f61fb935	190
8fc8598e JC	191	return NULL;
	192	}
	193
	194
	195	void free_ieee80211(struct net_device *dev)
	196	{
8fc8598e	197	struct ieee80211_device *ieee = netdev_priv(dev);
8fc8598e JC	198	int i;
	199	//struct list_head p, q;
	200	// del_timer_sync(&ieee->SwBwTimer);
8fc8598e JC	201	if (ieee->pHTInfo != NULL)
	202	{
	203	kfree(ieee->pHTInfo);
	204	ieee->pHTInfo = NULL;
	205	}
8fc8598e JC	206	RemoveAllTS(ieee);
	207	ieee80211_softmac_free(ieee);
	208	del_timer_sync(&ieee->crypt_deinit_timer);
	209	ieee80211_crypt_deinit_entries(ieee, 1);
	210
	211	for (i = 0; i < WEP_KEYS; i++) {
	212	struct ieee80211_crypt_data *crypt = ieee->crypt[i];
	213	if (crypt) {
f61fb935	214	if (crypt->ops)
8fc8598e	215	crypt->ops->deinit(crypt->priv);
8fc8598e JC	216	kfree(crypt);
	217	ieee->crypt[i] = NULL;
	218	}
	219	}
	220
	221	ieee80211_networks_free(ieee);
8fc8598e	222	free_netdev(dev);
8fc8598e JC	223	}
	224
	225	#ifdef CONFIG_IEEE80211_DEBUG
	226
	227	u32 ieee80211_debug_level = 0;
	228	static int debug = \
	229	// IEEE80211_DL_INFO \|
	230	// IEEE80211_DL_WX \|
	231	// IEEE80211_DL_SCAN \|
	232	// IEEE80211_DL_STATE \|
	233	// IEEE80211_DL_MGMT \|
	234	// IEEE80211_DL_FRAG \|
	235	// IEEE80211_DL_EAP \|
	236	// IEEE80211_DL_DROP \|
	237	// IEEE80211_DL_TX \|
	238	// IEEE80211_DL_RX \|
	239	//IEEE80211_DL_QOS \|
	240	// IEEE80211_DL_HT \|
	241	// IEEE80211_DL_TS \|
	242	// IEEE80211_DL_BA \|
	243	// IEEE80211_DL_REORDER\|
	244	// IEEE80211_DL_TRACE \|
	245	//IEEE80211_DL_DATA \|
	246	IEEE80211_DL_ERR //awayls open this flags to show error out
	247	;
	248	struct proc_dir_entry *ieee80211_proc = NULL;
	249
	250	static int show_debug_level(char page, char *start, off_t offset,
	251	int count, int eof, void data)
	252	{
	253	return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
	254	}
	255
	256	static int store_debug_level(struct file file, const char buffer,
	257	unsigned long count, void *data)
	258	{
	259	char buf[] = "0x00000000";
cf137d5c	260	unsigned long len = min_t(unsigned long, sizeof(buf) - 1, count);
8fc8598e JC	261	char p = (char )buf;
	262	unsigned long val;
	263
	264	if (copy_from_user(buf, buffer, len))
	265	return count;
	266	buf[len] = 0;
	267	if (p[1] == 'x' \|\| p[1] == 'X' \|\| p[0] == 'x' \|\| p[0] == 'X') {
	268	p++;
	269	if (p[0] == 'x' \|\| p[0] == 'X')
	270	p++;
	271	val = simple_strtoul(p, &p, 16);
	272	} else
	273	val = simple_strtoul(p, &p, 10);
	274	if (p == buf)
	275	printk(KERN_INFO DRV_NAME
	276	": %s is not in hex or decimal form.\n", buf);
	277	else
	278	ieee80211_debug_level = val;
	279
	280	return strnlen(buf, count);
	281	}
	282
f61fb935	283	int __init ieee80211_debug_init(void)
8fc8598e JC	284	{
	285	struct proc_dir_entry *e;
	286
	287	ieee80211_debug_level = debug;
f61fb935	288
8fc8598e	289	ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
8fc8598e JC	290	if (ieee80211_proc == NULL) {
	291	IEEE80211_ERROR("Unable to create " DRV_NAME
	292	" proc directory\n");
	293	return -EIO;
	294	}
	295	e = create_proc_entry("debug_level", S_IFREG \| S_IRUGO \| S_IWUSR,
	296	ieee80211_proc);
	297	if (!e) {
8fc8598e	298	remove_proc_entry(DRV_NAME, init_net.proc_net);
8fc8598e JC	299	ieee80211_proc = NULL;
	300	return -EIO;
	301	}
	302	e->read_proc = show_debug_level;
	303	e->write_proc = store_debug_level;
	304	e->data = NULL;
	305
	306	return 0;
	307	}
	308
f61fb935	309	void __exit ieee80211_debug_exit(void)
8fc8598e JC	310	{
	311	if (ieee80211_proc) {
	312	remove_proc_entry("debug_level", ieee80211_proc);
8fc8598e	313	remove_proc_entry(DRV_NAME, init_net.proc_net);
8fc8598e JC	314	ieee80211_proc = NULL;
	315	}
	316	}
	317
8fc8598e JC	318	#include <linux/moduleparam.h>
	319	module_param(debug, int, 0444);
	320	MODULE_PARM_DESC(debug, "debug output mask");
8fc8598e	321	#endif