net/ieee80211 -> drivers/net/ipw2x00/libipw_* rename
[linux-2.6.git] / drivers / net / wireless / ipw2x00 / libipw_module.c
1 /*******************************************************************************
2
3   Copyright(c) 2004-2005 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   <j@w1.fi>
9   Copyright (c) 2002-2003, Jouni Malinen <j@w1.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/proc_fs.h>
43 #include <linux/skbuff.h>
44 #include <linux/slab.h>
45 #include <linux/tcp.h>
46 #include <linux/types.h>
47 #include <linux/wireless.h>
48 #include <linux/etherdevice.h>
49 #include <asm/uaccess.h>
50 #include <net/net_namespace.h>
51 #include <net/arp.h>
52
53 #include <net/ieee80211.h>
54
55 #define DRV_DESCRIPTION "802.11 data/management/control stack"
56 #define DRV_NAME        "ieee80211"
57 #define DRV_VERSION     IEEE80211_VERSION
58 #define DRV_COPYRIGHT   "Copyright (C) 2004-2005 Intel Corporation <jketreno@linux.intel.com>"
59
60 MODULE_VERSION(DRV_VERSION);
61 MODULE_DESCRIPTION(DRV_DESCRIPTION);
62 MODULE_AUTHOR(DRV_COPYRIGHT);
63 MODULE_LICENSE("GPL");
64
65 static int ieee80211_networks_allocate(struct ieee80211_device *ieee)
66 {
67         if (ieee->networks)
68                 return 0;
69
70         ieee->networks =
71             kzalloc(MAX_NETWORK_COUNT * sizeof(struct ieee80211_network),
72                     GFP_KERNEL);
73         if (!ieee->networks) {
74                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
75                        ieee->dev->name);
76                 return -ENOMEM;
77         }
78
79         return 0;
80 }
81
82 void ieee80211_network_reset(struct ieee80211_network *network)
83 {
84         if (!network)
85                 return;
86
87         if (network->ibss_dfs) {
88                 kfree(network->ibss_dfs);
89                 network->ibss_dfs = NULL;
90         }
91 }
92
93 static inline void ieee80211_networks_free(struct ieee80211_device *ieee)
94 {
95         int i;
96
97         if (!ieee->networks)
98                 return;
99
100         for (i = 0; i < MAX_NETWORK_COUNT; i++)
101                 if (ieee->networks[i].ibss_dfs)
102                         kfree(ieee->networks[i].ibss_dfs);
103
104         kfree(ieee->networks);
105         ieee->networks = NULL;
106 }
107
108 static void ieee80211_networks_initialize(struct ieee80211_device *ieee)
109 {
110         int i;
111
112         INIT_LIST_HEAD(&ieee->network_free_list);
113         INIT_LIST_HEAD(&ieee->network_list);
114         for (i = 0; i < MAX_NETWORK_COUNT; i++)
115                 list_add_tail(&ieee->networks[i].list,
116                               &ieee->network_free_list);
117 }
118
119 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
120 {
121         if ((new_mtu < 68) || (new_mtu > IEEE80211_DATA_LEN))
122                 return -EINVAL;
123         dev->mtu = new_mtu;
124         return 0;
125 }
126
127 static struct net_device_stats *ieee80211_generic_get_stats(
128         struct net_device *dev)
129 {
130         struct ieee80211_device *ieee = netdev_priv(dev);
131         return &ieee->stats;
132 }
133
134 struct net_device *alloc_ieee80211(int sizeof_priv)
135 {
136         struct ieee80211_device *ieee;
137         struct net_device *dev;
138         int err;
139
140         IEEE80211_DEBUG_INFO("Initializing...\n");
141
142         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
143         if (!dev) {
144                 IEEE80211_ERROR("Unable to allocate network device.\n");
145                 goto failed;
146         }
147         ieee = netdev_priv(dev);
148         dev->hard_start_xmit = ieee80211_xmit;
149         dev->change_mtu = ieee80211_change_mtu;
150
151         /* Drivers are free to override this if the generic implementation
152          * does not meet their needs. */
153         dev->get_stats = ieee80211_generic_get_stats;
154
155         ieee->dev = dev;
156
157         err = ieee80211_networks_allocate(ieee);
158         if (err) {
159                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n", err);
160                 goto failed_free_netdev;
161         }
162         ieee80211_networks_initialize(ieee);
163
164         /* Default fragmentation threshold is maximum payload size */
165         ieee->fts = DEFAULT_FTS;
166         ieee->rts = DEFAULT_FTS;
167         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
168         ieee->open_wep = 1;
169
170         /* Default to enabling full open WEP with host based encrypt/decrypt */
171         ieee->host_encrypt = 1;
172         ieee->host_decrypt = 1;
173         ieee->host_mc_decrypt = 1;
174
175         /* Host fragementation in Open mode. Default is enabled.
176          * Note: host fragmentation is always enabled if host encryption
177          * is enabled. For cards can do hardware encryption, they must do
178          * hardware fragmentation as well. So we don't need a variable
179          * like host_enc_frag. */
180         ieee->host_open_frag = 1;
181         ieee->ieee802_1x = 1;   /* Default to supporting 802.1x */
182
183         spin_lock_init(&ieee->lock);
184
185         lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
186
187         ieee->wpa_enabled = 0;
188         ieee->drop_unencrypted = 0;
189         ieee->privacy_invoked = 0;
190
191         return dev;
192
193 failed_free_netdev:
194         free_netdev(dev);
195 failed:
196         return NULL;
197 }
198
199 void free_ieee80211(struct net_device *dev)
200 {
201         struct ieee80211_device *ieee = netdev_priv(dev);
202
203         lib80211_crypt_info_free(&ieee->crypt_info);
204
205         ieee80211_networks_free(ieee);
206         free_netdev(dev);
207 }
208
209 #ifdef CONFIG_IEEE80211_DEBUG
210
211 static int debug = 0;
212 u32 ieee80211_debug_level = 0;
213 EXPORT_SYMBOL_GPL(ieee80211_debug_level);
214 static struct proc_dir_entry *ieee80211_proc = NULL;
215
216 static int show_debug_level(char *page, char **start, off_t offset,
217                             int count, int *eof, void *data)
218 {
219         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
220 }
221
222 static int store_debug_level(struct file *file, const char __user * buffer,
223                              unsigned long count, void *data)
224 {
225         char buf[] = "0x00000000\n";
226         unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
227         unsigned long val;
228
229         if (copy_from_user(buf, buffer, len))
230                 return count;
231         buf[len] = 0;
232         if (sscanf(buf, "%li", &val) != 1)
233                 printk(KERN_INFO DRV_NAME
234                        ": %s is not in hex or decimal form.\n", buf);
235         else
236                 ieee80211_debug_level = val;
237
238         return strnlen(buf, len);
239 }
240 #endif                          /* CONFIG_IEEE80211_DEBUG */
241
242 static int __init ieee80211_init(void)
243 {
244 #ifdef CONFIG_IEEE80211_DEBUG
245         struct proc_dir_entry *e;
246
247         ieee80211_debug_level = debug;
248         ieee80211_proc = proc_mkdir(DRV_NAME, init_net.proc_net);
249         if (ieee80211_proc == NULL) {
250                 IEEE80211_ERROR("Unable to create " DRV_NAME
251                                 " proc directory\n");
252                 return -EIO;
253         }
254         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
255                               ieee80211_proc);
256         if (!e) {
257                 remove_proc_entry(DRV_NAME, init_net.proc_net);
258                 ieee80211_proc = NULL;
259                 return -EIO;
260         }
261         e->read_proc = show_debug_level;
262         e->write_proc = store_debug_level;
263         e->data = NULL;
264 #endif                          /* CONFIG_IEEE80211_DEBUG */
265
266         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
267         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
268
269         return 0;
270 }
271
272 static void __exit ieee80211_exit(void)
273 {
274 #ifdef CONFIG_IEEE80211_DEBUG
275         if (ieee80211_proc) {
276                 remove_proc_entry("debug_level", ieee80211_proc);
277                 remove_proc_entry(DRV_NAME, init_net.proc_net);
278                 ieee80211_proc = NULL;
279         }
280 #endif                          /* CONFIG_IEEE80211_DEBUG */
281 }
282
283 #ifdef CONFIG_IEEE80211_DEBUG
284 #include <linux/moduleparam.h>
285 module_param(debug, int, 0444);
286 MODULE_PARM_DESC(debug, "debug output mask");
287 #endif                          /* CONFIG_IEEE80211_DEBUG */
288
289 module_exit(ieee80211_exit);
290 module_init(ieee80211_init);
291
292 EXPORT_SYMBOL(alloc_ieee80211);
293 EXPORT_SYMBOL(free_ieee80211);