[GitHub/mt8127/android_kernel_alcatel_ttab.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 = kmalloc(
		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;
	}

	memset(ieee->networks, 0,
	       MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));

	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 = (RT_HIGH_THROUGHPUT*)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 1
	if (ieee->pHTInfo != NULL)
	{
		kfree(ieee->pHTInfo);
		ieee->pHTInfo = NULL;
	}
#endif
	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(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
68	ieee->networks = kmalloc(
69	MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
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
77	memset(ieee->networks, 0,
78	MAX_NETWORK_COUNT * sizeof(struct ieee80211_network));
79
80	return 0;
81	}
82
83	static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
84	{
85	if (!ieee->networks)
86	return;
87	kfree(ieee->networks);
88	ieee->networks = NULL;
89	}
90
91	static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
92	{
93	int i;
94
95	INIT_LIST_HEAD(&ieee->network_free_list);
96	INIT_LIST_HEAD(&ieee->network_list);
97	for (i = 0; i < MAX_NETWORK_COUNT; i++)
98	list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
99	}
100
101
102	struct net_device *alloc_ieee80211(int sizeof_priv)
103	{
104	struct ieee80211_device *ieee;
105	struct net_device *dev;
106	int i,err;
107
108	IEEE80211_DEBUG_INFO("Initializing...\n");
109
110	dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
111	if (!dev) {
112	IEEE80211_ERROR("Unable to network device.\n");
113	goto failed;
114	}
115
8fc8598e	116	ieee = netdev_priv(dev);
8fc8598e JC	117	memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv);
	118	ieee->dev = dev;
	119
	120	err = ieee80211_networks_allocate(ieee);
	121	if (err) {
	122	IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
	123	err);
	124	goto failed;
	125	}
	126	ieee80211_networks_initialize(ieee);
	127
	128
	129	/* Default fragmentation threshold is maximum payload size */
	130	ieee->fts = DEFAULT_FTS;
	131	ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
	132	ieee->open_wep = 1;
	133
	134	/* Default to enabling full open WEP with host based encrypt/decrypt */
	135	ieee->host_encrypt = 1;
	136	ieee->host_decrypt = 1;
	137	ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
	138
	139	INIT_LIST_HEAD(&ieee->crypt_deinit_list);
	140	init_timer(&ieee->crypt_deinit_timer);
	141	ieee->crypt_deinit_timer.data = (unsigned long)ieee;
	142	ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
	143
	144	spin_lock_init(&ieee->lock);
	145	spin_lock_init(&ieee->wpax_suitlist_lock);
	146	spin_lock_init(&ieee->bw_spinlock);
	147	spin_lock_init(&ieee->reorder_spinlock);
	148	//added by WB
	149	atomic_set(&(ieee->atm_chnlop), 0);
	150	atomic_set(&(ieee->atm_swbw), 0);
	151
	152	ieee->wpax_type_set = 0;
e406322b MCC	153	ieee->wpa_enabled = 0;
	154	ieee->tkip_countermeasures = 0;
	155	ieee->drop_unencrypted = 0;
	156	ieee->privacy_invoked = 0;
	157	ieee->ieee802_1x = 1;
8fc8598e JC	158	ieee->raw_tx = 0;
	159	//ieee->hwsec_support = 1; //defalt support hw security. //use module_param instead.
	160	ieee->hwsec_active = 0; //disable hwsec, switch it on when necessary.
	161
	162	ieee80211_softmac_init(ieee);
	163
8fc8598e	164	ieee->pHTInfo = (RT_HIGH_THROUGHPUT*)kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
8fc8598e JC	165	if (ieee->pHTInfo == NULL)
	166	{
	167	IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
	168	return NULL;
	169	}
	170	HTUpdateDefaultSetting(ieee);
	171	HTInitializeHTInfo(ieee); //may move to other place.
	172	TSInitialize(ieee);
f61fb935	173
8fc8598e JC	174	for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
	175	INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
	176
	177	for (i = 0; i < 17; i++) {
	178	ieee->last_rxseq_num[i] = -1;
	179	ieee->last_rxfrag_num[i] = -1;
	180	ieee->last_packet_time[i] = 0;
	181	}
	182
	183	//These function were added to load crypte module autoly
	184	ieee80211_tkip_null();
	185	ieee80211_wep_null();
	186	ieee80211_ccmp_null();
	187
	188	return dev;
	189
	190	failed:
	191	if (dev)
8fc8598e	192	free_netdev(dev);
f61fb935	193
8fc8598e JC	194	return NULL;
	195	}
	196
	197
	198	void free_ieee80211(struct net_device *dev)
	199	{
8fc8598e	200	struct ieee80211_device *ieee = netdev_priv(dev);
8fc8598e JC	201	int i;
	202	//struct list_head p, q;
	203	// del_timer_sync(&ieee->SwBwTimer);
	204	#if 1
	205	if (ieee->pHTInfo != NULL)
	206	{
	207	kfree(ieee->pHTInfo);
	208	ieee->pHTInfo = NULL;
	209	}
	210	#endif
	211	RemoveAllTS(ieee);
	212	ieee80211_softmac_free(ieee);
	213	del_timer_sync(&ieee->crypt_deinit_timer);
	214	ieee80211_crypt_deinit_entries(ieee, 1);
	215
	216	for (i = 0; i < WEP_KEYS; i++) {
	217	struct ieee80211_crypt_data *crypt = ieee->crypt[i];
	218	if (crypt) {
f61fb935	219	if (crypt->ops)
8fc8598e	220	crypt->ops->deinit(crypt->priv);
8fc8598e JC	221	kfree(crypt);
	222	ieee->crypt[i] = NULL;
	223	}
	224	}
	225
	226	ieee80211_networks_free(ieee);
8fc8598e	227	free_netdev(dev);
8fc8598e JC	228	}
	229
	230	#ifdef CONFIG_IEEE80211_DEBUG
	231
	232	u32 ieee80211_debug_level = 0;
	233	static int debug = \
	234	// IEEE80211_DL_INFO \|
	235	// IEEE80211_DL_WX \|
	236	// IEEE80211_DL_SCAN \|
	237	// IEEE80211_DL_STATE \|
	238	// IEEE80211_DL_MGMT \|
	239	// IEEE80211_DL_FRAG \|
	240	// IEEE80211_DL_EAP \|
	241	// IEEE80211_DL_DROP \|
	242	// IEEE80211_DL_TX \|
	243	// IEEE80211_DL_RX \|
	244	//IEEE80211_DL_QOS \|
	245	// IEEE80211_DL_HT \|
	246	// IEEE80211_DL_TS \|
	247	// IEEE80211_DL_BA \|
	248	// IEEE80211_DL_REORDER\|
	249	// IEEE80211_DL_TRACE \|
	250	//IEEE80211_DL_DATA \|
	251	IEEE80211_DL_ERR //awayls open this flags to show error out
	252	;
	253	struct proc_dir_entry *ieee80211_proc = NULL;
	254
	255	static int show_debug_level(char page, char *start, off_t offset,
	256	int count, int eof, void data)
	257	{
	258	return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
	259	}
	260
	261	static int store_debug_level(struct file file, const char buffer,
	262	unsigned long count, void *data)
	263	{
	264	char buf[] = "0x00000000";
f61fb935	265	unsigned long len = min(sizeof(buf) - 1, count);
8fc8598e JC	266	char p = (char )buf;
	267	unsigned long val;
	268
	269	if (copy_from_user(buf, buffer, len))
	270	return count;
	271	buf[len] = 0;
	272	if (p[1] == 'x' \|\| p[1] == 'X' \|\| p[0] == 'x' \|\| p[0] == 'X') {
	273	p++;
	274	if (p[0] == 'x' \|\| p[0] == 'X')
	275	p++;
	276	val = simple_strtoul(p, &p, 16);
	277	} else
	278	val = simple_strtoul(p, &p, 10);
	279	if (p == buf)
	280	printk(KERN_INFO DRV_NAME
	281	": %s is not in hex or decimal form.\n", buf);
	282	else
	283	ieee80211_debug_level = val;
	284
	285	return strnlen(buf, count);
	286	}
	287
f61fb935	288	int __init ieee80211_debug_init(void)
8fc8598e JC	289	{
	290	struct proc_dir_entry *e;
	291
	292	ieee80211_debug_level = debug;
f61fb935	293
8fc8598e	294	ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
8fc8598e JC	295	if (ieee80211_proc == NULL) {
	296	IEEE80211_ERROR("Unable to create " DRV_NAME
	297	" proc directory\n");
	298	return -EIO;
	299	}
	300	e = create_proc_entry("debug_level", S_IFREG \| S_IRUGO \| S_IWUSR,
	301	ieee80211_proc);
	302	if (!e) {
8fc8598e	303	remove_proc_entry(DRV_NAME, init_net.proc_net);
8fc8598e JC	304	ieee80211_proc = NULL;
	305	return -EIO;
	306	}
	307	e->read_proc = show_debug_level;
	308	e->write_proc = store_debug_level;
	309	e->data = NULL;
	310
	311	return 0;
	312	}
	313
f61fb935	314	void __exit ieee80211_debug_exit(void)
8fc8598e JC	315	{
	316	if (ieee80211_proc) {
	317	remove_proc_entry("debug_level", ieee80211_proc);
8fc8598e	318	remove_proc_entry(DRV_NAME, init_net.proc_net);
8fc8598e JC	319	ieee80211_proc = NULL;
	320	}
	321	}
	322
8fc8598e JC	323	#include <linux/moduleparam.h>
	324	module_param(debug, int, 0444);
	325	MODULE_PARM_DESC(debug, "debug output mask");
8fc8598e	326	#endif