1 /*******************************************************************************
3 Copyright(c) 2004-2005 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 <j@w1.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 Intel Linux Wireless <ilw@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/errno.h>
35 #include <linux/if_arp.h>
36 #include <linux/in6.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>
55 #define DRV_DESCRIPTION "802.11 data/management/control stack"
56 #define DRV_NAME "ieee80211"
57 #define DRV_VERSION LIBIPW_VERSION
58 #define DRV_COPYRIGHT "Copyright (C) 2004-2005 Intel Corporation <jketreno@linux.intel.com>"
60 MODULE_VERSION(DRV_VERSION);
61 MODULE_DESCRIPTION(DRV_DESCRIPTION);
62 MODULE_AUTHOR(DRV_COPYRIGHT);
63 MODULE_LICENSE("GPL");
65 struct cfg80211_ops libipw_config_ops = { };
66 void *libipw_wiphy_privid = &libipw_wiphy_privid;
68 static int libipw_networks_allocate(struct libipw_device *ieee)
72 for (i = 0; i < MAX_NETWORK_COUNT; i++) {
73 ieee->networks[i] = kzalloc(sizeof(struct libipw_network),
75 if (!ieee->networks[i]) {
76 LIBIPW_ERROR("Out of memory allocating beacons\n");
77 for (j = 0; j < i; j++)
78 kfree(ieee->networks[j]);
86 void libipw_network_reset(struct libipw_network *network)
91 if (network->ibss_dfs) {
92 kfree(network->ibss_dfs);
93 network->ibss_dfs = NULL;
97 static inline void libipw_networks_free(struct libipw_device *ieee)
101 for (i = 0; i < MAX_NETWORK_COUNT; i++) {
102 if (ieee->networks[i]->ibss_dfs)
103 kfree(ieee->networks[i]->ibss_dfs);
104 kfree(ieee->networks[i]);
108 void libipw_networks_age(struct libipw_device *ieee,
109 unsigned long age_secs)
111 struct libipw_network *network = NULL;
113 unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
115 spin_lock_irqsave(&ieee->lock, flags);
116 list_for_each_entry(network, &ieee->network_list, list) {
117 network->last_scanned -= age_jiffies;
119 spin_unlock_irqrestore(&ieee->lock, flags);
121 EXPORT_SYMBOL(libipw_networks_age);
123 static void libipw_networks_initialize(struct libipw_device *ieee)
127 INIT_LIST_HEAD(&ieee->network_free_list);
128 INIT_LIST_HEAD(&ieee->network_list);
129 for (i = 0; i < MAX_NETWORK_COUNT; i++)
130 list_add_tail(&ieee->networks[i]->list,
131 &ieee->network_free_list);
134 int libipw_change_mtu(struct net_device *dev, int new_mtu)
136 if ((new_mtu < 68) || (new_mtu > LIBIPW_DATA_LEN))
141 EXPORT_SYMBOL(libipw_change_mtu);
143 struct net_device *alloc_ieee80211(int sizeof_priv, int monitor)
145 struct libipw_device *ieee;
146 struct net_device *dev;
149 LIBIPW_DEBUG_INFO("Initializing...\n");
151 dev = alloc_etherdev(sizeof(struct libipw_device) + sizeof_priv);
153 LIBIPW_ERROR("Unable to allocate network device.\n");
156 ieee = netdev_priv(dev);
161 ieee->wdev.wiphy = wiphy_new(&libipw_config_ops, 0);
162 if (!ieee->wdev.wiphy) {
163 LIBIPW_ERROR("Unable to allocate wiphy.\n");
164 goto failed_free_netdev;
167 ieee->dev->ieee80211_ptr = &ieee->wdev;
168 ieee->wdev.iftype = NL80211_IFTYPE_STATION;
170 /* Fill-out wiphy structure bits we know... Not enough info
171 here to call set_wiphy_dev or set MAC address or channel info
172 -- have to do that in ->ndo_init... */
173 ieee->wdev.wiphy->privid = libipw_wiphy_privid;
175 ieee->wdev.wiphy->max_scan_ssids = 1;
176 ieee->wdev.wiphy->max_scan_ie_len = 0;
177 ieee->wdev.wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
178 | BIT(NL80211_IFTYPE_ADHOC);
181 err = libipw_networks_allocate(ieee);
183 LIBIPW_ERROR("Unable to allocate beacon storage: %d\n", err);
184 goto failed_free_wiphy;
186 libipw_networks_initialize(ieee);
188 /* Default fragmentation threshold is maximum payload size */
189 ieee->fts = DEFAULT_FTS;
190 ieee->rts = DEFAULT_FTS;
191 ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
194 /* Default to enabling full open WEP with host based encrypt/decrypt */
195 ieee->host_encrypt = 1;
196 ieee->host_decrypt = 1;
197 ieee->host_mc_decrypt = 1;
199 /* Host fragmentation in Open mode. Default is enabled.
200 * Note: host fragmentation is always enabled if host encryption
201 * is enabled. For cards can do hardware encryption, they must do
202 * hardware fragmentation as well. So we don't need a variable
203 * like host_enc_frag. */
204 ieee->host_open_frag = 1;
205 ieee->ieee802_1x = 1; /* Default to supporting 802.1x */
207 spin_lock_init(&ieee->lock);
209 lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
211 ieee->wpa_enabled = 0;
212 ieee->drop_unencrypted = 0;
213 ieee->privacy_invoked = 0;
219 wiphy_free(ieee->wdev.wiphy);
226 void free_ieee80211(struct net_device *dev, int monitor)
228 struct libipw_device *ieee = netdev_priv(dev);
230 lib80211_crypt_info_free(&ieee->crypt_info);
232 libipw_networks_free(ieee);
234 /* free cfg80211 resources */
236 wiphy_free(ieee->wdev.wiphy);
241 #ifdef CONFIG_LIBIPW_DEBUG
243 static int debug = 0;
244 u32 libipw_debug_level = 0;
245 EXPORT_SYMBOL_GPL(libipw_debug_level);
246 static struct proc_dir_entry *libipw_proc = NULL;
248 static int debug_level_proc_show(struct seq_file *m, void *v)
250 seq_printf(m, "0x%08X\n", libipw_debug_level);
254 static int debug_level_proc_open(struct inode *inode, struct file *file)
256 return single_open(file, debug_level_proc_show, NULL);
259 static ssize_t debug_level_proc_write(struct file *file,
260 const char __user *buffer, size_t count, loff_t *pos)
262 char buf[] = "0x00000000\n";
263 size_t len = min(sizeof(buf) - 1, count);
266 if (copy_from_user(buf, buffer, len))
269 if (sscanf(buf, "%li", &val) != 1)
270 printk(KERN_INFO DRV_NAME
271 ": %s is not in hex or decimal form.\n", buf);
273 libipw_debug_level = val;
275 return strnlen(buf, len);
278 static const struct file_operations debug_level_proc_fops = {
279 .owner = THIS_MODULE,
280 .open = debug_level_proc_open,
283 .release = single_release,
284 .write = debug_level_proc_write,
286 #endif /* CONFIG_LIBIPW_DEBUG */
288 static int __init libipw_init(void)
290 #ifdef CONFIG_LIBIPW_DEBUG
291 struct proc_dir_entry *e;
293 libipw_debug_level = debug;
294 libipw_proc = proc_mkdir(DRV_NAME, init_net.proc_net);
295 if (libipw_proc == NULL) {
296 LIBIPW_ERROR("Unable to create " DRV_NAME
297 " proc directory\n");
300 e = proc_create("debug_level", S_IRUGO | S_IWUSR, libipw_proc,
301 &debug_level_proc_fops);
303 remove_proc_entry(DRV_NAME, init_net.proc_net);
307 #endif /* CONFIG_LIBIPW_DEBUG */
309 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
310 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
315 static void __exit libipw_exit(void)
317 #ifdef CONFIG_LIBIPW_DEBUG
319 remove_proc_entry("debug_level", libipw_proc);
320 remove_proc_entry(DRV_NAME, init_net.proc_net);
323 #endif /* CONFIG_LIBIPW_DEBUG */
326 #ifdef CONFIG_LIBIPW_DEBUG
327 #include <linux/moduleparam.h>
328 module_param(debug, int, 0444);
329 MODULE_PARM_DESC(debug, "debug output mask");
330 #endif /* CONFIG_LIBIPW_DEBUG */
332 module_exit(libipw_exit);
333 module_init(libipw_init);
335 EXPORT_SYMBOL(alloc_ieee80211);
336 EXPORT_SYMBOL(free_ieee80211);