663b0b8e109500fd4baf376b8171a1e98eb567ff
[linux-2.6.git] / drivers / staging / rtl8192e / ieee80211 / ieee80211_module.c
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/errno.h>
35 #include <linux/if_arp.h>
36 #include <linux/in6.h>
37 #include <linux/in.h>
38 #include <linux/ip.h>
39 #include <linux/kernel.h>
40 #include <linux/module.h>
41 #include <linux/netdevice.h>
42 #include <linux/pci.h>
43 #include <linux/proc_fs.h>
44 #include <linux/skbuff.h>
45 #include <linux/slab.h>
46 #include <linux/tcp.h>
47 #include <linux/types.h>
48 #include <linux/version.h>
49 #include <linux/wireless.h>
50 #include <linux/etherdevice.h>
51 #include <asm/uaccess.h>
52 #include <net/arp.h>
53
54 #include "ieee80211.h"
55
56 MODULE_DESCRIPTION("802.11 data/management/control stack");
57 MODULE_AUTHOR("Copyright (C) 2004 Intel Corporation <jketreno@linux.intel.com>");
58 MODULE_LICENSE("GPL");
59
60 #define DRV_NAME "ieee80211"
61
62 static inline int ieee80211_networks_allocate(struct ieee80211_device *ieee)
63 {
64         if (ieee->networks)
65                 return 0;
66
67         ieee->networks = kcalloc(
68                 MAX_NETWORK_COUNT, sizeof(struct ieee80211_network),
69                 GFP_KERNEL);
70         if (!ieee->networks) {
71                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
72                         ieee->dev->name);
73                 return -ENOMEM;
74         }
75
76         return 0;
77 }
78
79 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
80 {
81         if (!ieee->networks)
82                 return;
83         kfree(ieee->networks);
84         ieee->networks = NULL;
85 }
86
87 static inline void ieee80211_networks_initialize(struct ieee80211_device *ieee)
88 {
89         int i;
90
91         INIT_LIST_HEAD(&ieee->network_free_list);
92         INIT_LIST_HEAD(&ieee->network_list);
93         for (i = 0; i < MAX_NETWORK_COUNT; i++)
94                 list_add_tail(&ieee->networks[i].list, &ieee->network_free_list);
95 }
96
97
98 struct net_device *alloc_ieee80211(int sizeof_priv)
99 {
100         struct ieee80211_device *ieee;
101         struct net_device *dev;
102         int i, err;
103
104         IEEE80211_DEBUG_INFO("Initializing...\n");
105
106         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
107         if (!dev) {
108                 IEEE80211_ERROR("Unable to network device.\n");
109                 goto failed;
110         }
111
112         ieee = netdev_priv(dev);
113
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
146         /* added by WB */
147         atomic_set(&(ieee->atm_chnlop), 0);
148         atomic_set(&(ieee->atm_swbw), 0);
149
150         ieee->wpax_type_set = 0;
151         ieee->wpa_enabled = 0;
152         ieee->tkip_countermeasures = 0;
153         ieee->drop_unencrypted = 0;
154         ieee->privacy_invoked = 0;
155         ieee->ieee802_1x = 1;
156         ieee->raw_tx = 0;
157         /* ieee->hwsec_support = 1; default support hw security: use module_param instead */
158         ieee->hwsec_active = 0; /* disable hwsec, switch it on when necessary */
159
160         ieee80211_softmac_init(ieee);
161
162         ieee->pHTInfo = kzalloc(sizeof(RT_HIGH_THROUGHPUT), GFP_KERNEL);
163         if (ieee->pHTInfo == NULL)
164         {
165                 IEEE80211_DEBUG(IEEE80211_DL_ERR, "can't alloc memory for HTInfo\n");
166                 return NULL;
167         }
168         HTUpdateDefaultSetting(ieee);
169         HTInitializeHTInfo(ieee); /* may move to other place */
170         TSInitialize(ieee);
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         /* Functions to load crypt module automatically */
181         ieee80211_tkip_null();
182         ieee80211_wep_null();
183         ieee80211_ccmp_null();
184
185         return dev;
186
187 failed:
188         if (dev)
189                 free_netdev(dev);
190         return NULL;
191 }
192
193
194 void free_ieee80211(struct net_device *dev)
195 {
196         struct ieee80211_device *ieee = netdev_priv(dev);
197         int i;
198         kfree(ieee->pHTInfo);
199         ieee->pHTInfo = NULL;
200         RemoveAllTS(ieee);
201         ieee80211_softmac_free(ieee);
202         del_timer_sync(&ieee->crypt_deinit_timer);
203         ieee80211_crypt_deinit_entries(ieee, 1);
204
205         for (i = 0; i < WEP_KEYS; i++) {
206                 struct ieee80211_crypt_data *crypt = ieee->crypt[i];
207                 if (crypt) {
208                         if (crypt->ops)
209                                 crypt->ops->deinit(crypt->priv);
210                         kfree(crypt);
211                         ieee->crypt[i] = NULL;
212                 }
213         }
214
215         ieee80211_networks_free(ieee);
216         free_netdev(dev);
217 }
218
219 #ifdef CONFIG_IEEE80211_DEBUG
220
221 u32 ieee80211_debug_level = 0;
222 static int debug =
223         /* IEEE80211_DL_INFO    | */
224         /* IEEE80211_DL_WX      | */
225         /* IEEE80211_DL_SCAN    | */
226         /* IEEE80211_DL_STATE   | */
227         /* IEEE80211_DL_MGMT    | */
228         /* IEEE80211_DL_FRAG    | */
229         /* IEEE80211_DL_EAP     | */
230         /* IEEE80211_DL_DROP    | */
231         /* IEEE80211_DL_TX      | */
232         /* IEEE80211_DL_RX      | */
233         /* IEEE80211_DL_QOS     | */
234         /* IEEE80211_DL_HT      | */
235         /* IEEE80211_DL_TS      | */
236         /* IEEE80211_DL_BA      | */
237         /* IEEE80211_DL_REORDER | */
238         /* IEEE80211_DL_TRACE   | */
239         /* IEEE80211_DL_DATA    | */
240         IEEE80211_DL_ERR        /* always open this flag to show error out */
241         ;
242 struct proc_dir_entry *ieee80211_proc = NULL;
243
244 static int show_debug_level(char *page, char **start, off_t offset,
245                         int count, int *eof, void *data)
246 {
247         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
248 }
249
250 static int store_debug_level(struct file *file, const char *buffer,
251                         unsigned long count, void *data)
252 {
253         char buf[] = "0x00000000";
254         unsigned long len = min(sizeof(buf) - 1, (u32)count);
255         char *p = (char *)buf;
256         unsigned long val;
257
258         if (copy_from_user(buf, buffer, len))
259                 return count;
260         buf[len] = 0;
261         if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
262                 p++;
263                 if (p[0] == 'x' || p[0] == 'X')
264                         p++;
265                 val = simple_strtoul(p, &p, 16);
266         } else
267                 val = simple_strtoul(p, &p, 10);
268         if (p == buf)
269                 printk(KERN_INFO DRV_NAME
270                         ": %s is not in hex or decimal form.\n", buf);
271         else
272                 ieee80211_debug_level = val;
273
274         return strnlen(buf, count);
275 }
276
277 extern int ieee80211_crypto_init(void);
278 extern void ieee80211_crypto_deinit(void);
279 extern int ieee80211_crypto_tkip_init(void);
280 extern void ieee80211_crypto_tkip_exit(void);
281 extern int ieee80211_crypto_ccmp_init(void);
282 extern void ieee80211_crypto_ccmp_exit(void);
283 extern int ieee80211_crypto_wep_init(void);
284 extern void ieee80211_crypto_wep_exit(void);
285
286 int __init ieee80211_rtl_init(void)
287 {
288         struct proc_dir_entry *e;
289         int retval;
290
291         retval = ieee80211_crypto_init();
292         if (retval)
293                 return retval;
294         retval = ieee80211_crypto_tkip_init();
295         if (retval) {
296                 ieee80211_crypto_deinit();
297                 return retval;
298         }
299         retval = ieee80211_crypto_ccmp_init();
300         if (retval) {
301                 ieee80211_crypto_tkip_exit();
302                 ieee80211_crypto_deinit();
303                 return retval;
304         }
305         retval = ieee80211_crypto_wep_init();
306         if (retval) {
307                 ieee80211_crypto_ccmp_exit();
308                 ieee80211_crypto_tkip_exit();
309                 ieee80211_crypto_deinit();
310                 return retval;
311         }
312
313         ieee80211_debug_level = debug;
314         ieee80211_proc = create_proc_entry(DRV_NAME, S_IFDIR, init_net.proc_net);
315         if (ieee80211_proc == NULL) {
316                 IEEE80211_ERROR("Unable to create " DRV_NAME
317                                 " proc directory\n");
318                 return -EIO;
319         }
320         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
321                         ieee80211_proc);
322         if (!e) {
323                 remove_proc_entry(DRV_NAME, init_net.proc_net);
324                 ieee80211_proc = NULL;
325                 return -EIO;
326         }
327         e->read_proc = show_debug_level;
328         e->write_proc = store_debug_level;
329         e->data = NULL;
330
331         return 0;
332 }
333
334 void __exit ieee80211_rtl_exit(void)
335 {
336         if (ieee80211_proc) {
337                 remove_proc_entry("debug_level", ieee80211_proc);
338                 remove_proc_entry(DRV_NAME, init_net.proc_net);
339                 ieee80211_proc = NULL;
340         }
341         ieee80211_crypto_wep_exit();
342         ieee80211_crypto_ccmp_exit();
343         ieee80211_crypto_tkip_exit();
344         ieee80211_crypto_deinit();
345 }
346
347 #include <linux/moduleparam.h>
348 module_param(debug, int, 0444);
349 MODULE_PARM_DESC(debug, "debug output mask");
350
351
352 #endif
353