1 /*******************************************************************************
3 Copyright(c) 2004 Intel Corporation. All rights reserved.
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
9 Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
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.
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
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.
24 The full GNU General Public License is included in this distribution in the
28 James P. Ketrenos <ipw2100-admin@linux.intel.com>
29 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
31 *******************************************************************************/
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>
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>
55 #include "ieee80211.h"
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");
61 #define DRV_NAME "ieee80211"
63 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
68 ieee->networks = kcalloc(
69 MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
71 if (!ieee->networks) {
72 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
80 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
84 kfree(ieee->networks);
85 ieee->networks = NULL;
88 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
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);
99 struct net_device *alloc_ieee80211(int sizeof_priv)
101 struct ieee80211_device *ieee;
102 struct net_device *dev;
105 IEEE80211_DEBUG_INFO("Initializing...\n");
107 dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
109 IEEE80211_ERROR("Unable to network device.\n");
113 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
114 ieee = netdev_priv(dev);
116 ieee = (struct ieee80211_device *)dev->priv;
119 dev->hard_start_xmit = ieee80211_rtl_xmit;
122 memset(ieee, 0, sizeof(struct ieee80211_device)+sizeof_priv);
125 err = ieee80211_networks_allocate(ieee);
127 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n",
131 ieee80211_networks_initialize(ieee);
134 /* Default fragmentation threshold is maximum payload size */
135 ieee->fts = DEFAULT_FTS;
136 ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
139 /* Default to enabling full open WEP with host based encrypt/decrypt */
140 ieee->host_encrypt = 1;
141 ieee->host_decrypt = 1;
142 ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
144 INIT_LIST_HEAD(&ieee->crypt_deinit_list);
145 init_timer(&ieee->crypt_deinit_timer);
146 ieee->crypt_deinit_timer.data = (unsigned long)ieee;
147 ieee->crypt_deinit_timer.function = ieee80211_crypt_deinit_handler;
149 spin_lock_init(&ieee->lock);
150 spin_lock_init(&ieee->wpax_suitlist_lock);
151 spin_lock_init(&ieee->bw_spinlock);
152 spin_lock_init(&ieee->reorder_spinlock);
154 atomic_set(&(ieee->atm_chnlop), 0);
155 atomic_set(&(ieee->atm_swbw), 0);
157 ieee->wpax_type_set = 0;
158 ieee->wpa_enabled = 0;
159 ieee->tkip_countermeasures = 0;
160 ieee->drop_unencrypted = 0;
161 ieee->privacy_invoked = 0;
162 ieee->ieee802_1x = 1;
164 //ieee->hwsec_support = 1; //default support hw security. //use module_param instead.
165 ieee->hwsec_active = 0; //disable hwsec, switch it on when necessary.
167 ieee80211_softmac_init(ieee);
169 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
170 ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
172 ieee->pHTInfo = (RT_HIGH_THROUGHPUT*)kmalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
173 memset(ieee->pHTInfo,0,sizeof(RT_HIGH_THROUGHPUT));
175 if (ieee->pHTInfo == NULL)
177 IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
180 HTUpdateDefaultSetting(ieee);
181 HTInitializeHTInfo(ieee); //may move to other place.
184 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
185 INIT_WORK(&ieee->ht_onAssRsp, (void(*)(void*)) HTOnAssocRsp_wq);
187 INIT_WORK(&ieee->ht_onAssRsp, (void(*)(void*)) HTOnAssocRsp_wq, ieee);
190 for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++)
191 INIT_LIST_HEAD(&ieee->ibss_mac_hash[i]);
193 for (i = 0; i < 17; i++) {
194 ieee->last_rxseq_num[i] = -1;
195 ieee->last_rxfrag_num[i] = -1;
196 ieee->last_packet_time[i] = 0;
199 //These function were added to load crypte module autoly
200 ieee80211_tkip_null();
201 ieee80211_wep_null();
202 ieee80211_ccmp_null();
208 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
217 void free_ieee80211(struct net_device *dev)
219 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
220 struct ieee80211_device *ieee = netdev_priv(dev);
222 struct ieee80211_device *ieee = (struct ieee80211_device *)dev->priv;
225 //struct list_head *p, *q;
226 // del_timer_sync(&ieee->SwBwTimer);
228 if (ieee->pHTInfo != NULL)
230 kfree(ieee->pHTInfo);
231 ieee->pHTInfo = NULL;
235 ieee80211_softmac_free(ieee);
236 del_timer_sync(&ieee->crypt_deinit_timer);
237 ieee80211_crypt_deinit_entries(ieee, 1);
239 for (i = 0; i < WEP_KEYS; i++) {
240 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
243 crypt->ops->deinit(crypt->priv);
245 ieee->crypt[i] = NULL;
249 ieee80211_networks_free(ieee);
251 for (i = 0; i < IEEE_IBSS_MAC_HASH_SIZE; i++) {
252 list_for_each_safe(p, q, &ieee->ibss_mac_hash[i]) {
253 kfree(list_entry(p, struct ieee_ibss_seq, list));
259 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
266 #ifdef CONFIG_IEEE80211_DEBUG
268 u32 ieee80211_debug_level = 0;
270 // IEEE80211_DL_INFO |
272 // IEEE80211_DL_SCAN |
273 // IEEE80211_DL_STATE |
274 // IEEE80211_DL_MGMT |
275 // IEEE80211_DL_FRAG |
276 // IEEE80211_DL_EAP |
277 // IEEE80211_DL_DROP |
284 // IEEE80211_DL_REORDER|
285 // IEEE80211_DL_TRACE |
286 //IEEE80211_DL_DATA |
287 IEEE80211_DL_ERR //awayls open this flags to show error out
289 struct proc_dir_entry *ieee80211_proc = NULL;
291 static int show_debug_level(char *page, char **start, off_t offset,
292 int count, int *eof, void *data)
294 return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
297 static int store_debug_level(struct file *file, const char *buffer,
298 unsigned long count, void *data)
300 char buf[] = "0x00000000";
301 unsigned long len = min(sizeof(buf) - 1, (u32)count);
302 char *p = (char *)buf;
305 if (copy_from_user(buf, buffer, len))
308 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
310 if (p[0] == 'x' || p[0] == 'X')
312 val = simple_strtoul(p, &p, 16);
314 val = simple_strtoul(p, &p, 10);
316 printk(KERN_INFO DRV_NAME
317 ": %s is not in hex or decimal form.\n", buf);
319 ieee80211_debug_level = val;
321 return strnlen(buf, count);
324 extern int ieee80211_crypto_init(void);
325 extern void ieee80211_crypto_deinit(void);
326 extern int ieee80211_crypto_tkip_init(void);
327 extern void ieee80211_crypto_tkip_exit(void);
328 extern int ieee80211_crypto_ccmp_init(void);
329 extern void ieee80211_crypto_ccmp_exit(void);
330 extern int ieee80211_crypto_wep_init(void);
331 extern void ieee80211_crypto_wep_exit(void);
333 int __init ieee80211_rtl_init(void)
335 struct proc_dir_entry *e;
338 retval = ieee80211_crypto_init();
341 retval = ieee80211_crypto_tkip_init();
343 ieee80211_crypto_deinit();
346 retval = ieee80211_crypto_ccmp_init();
348 ieee80211_crypto_tkip_exit();
349 ieee80211_crypto_deinit();
352 retval = ieee80211_crypto_wep_init();
354 ieee80211_crypto_ccmp_exit();
355 ieee80211_crypto_tkip_exit();
356 ieee80211_crypto_deinit();
360 ieee80211_debug_level = debug;
361 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
362 ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, proc_net);
364 ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
366 if (ieee80211_proc == NULL) {
367 IEEE80211_ERROR("Unable to create " DRV_NAME
368 " proc directory\n");
371 e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
374 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
375 remove_proc_entry(DRV_NAME, proc_net);
377 remove_proc_entry(DRV_NAME, init_net.proc_net);
379 ieee80211_proc = NULL;
382 e->read_proc = show_debug_level;
383 e->write_proc = store_debug_level;
389 void __exit ieee80211_rtl_exit(void)
391 if (ieee80211_proc) {
392 remove_proc_entry("debug_level", ieee80211_proc);
393 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
394 remove_proc_entry(DRV_NAME, proc_net);
396 remove_proc_entry(DRV_NAME, init_net.proc_net);
398 ieee80211_proc = NULL;
400 ieee80211_crypto_wep_exit();
401 ieee80211_crypto_ccmp_exit();
402 ieee80211_crypto_tkip_exit();
403 ieee80211_crypto_deinit();
406 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
407 #include <linux/moduleparam.h>
408 module_param(debug, int, 0444);
409 MODULE_PARM_DESC(debug, "debug output mask");
412 //module_exit(ieee80211_rtl_exit);
413 //module_init(ieee80211_rtl_init);
417 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
418 //EXPORT_SYMBOL(alloc_ieee80211);
419 //EXPORT_SYMBOL(free_ieee80211);
421 EXPORT_SYMBOL_NOVERS(alloc_ieee80211);
422 EXPORT_SYMBOL_NOVERS(free_ieee80211);