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 "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 void ieee80211_networks_age(struct ieee80211_device *ieee,
 109                             unsigned long age_secs)
 110 {
 111         struct ieee80211_network *network = NULL;
 112         unsigned long flags;
 113         unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
 114
 115         spin_lock_irqsave(&ieee->lock, flags);
 116         list_for_each_entry(network, &ieee->network_list, list) {
 117                 network->last_scanned -= age_jiffies;
 118         }
 119         spin_unlock_irqrestore(&ieee->lock, flags);
 120 }
 121 EXPORT_SYMBOL(ieee80211_networks_age);
 122
 123 static void ieee80211_networks_initialize(struct ieee80211_device *ieee)
 124 {
 125         int i;
 126
 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);
 132 }
 133
 134 static int ieee80211_change_mtu(struct net_device *dev, int new_mtu)
 135 {
 136         if ((new_mtu < 68) || (new_mtu > IEEE80211_DATA_LEN))
 137                 return -EINVAL;
 138         dev->mtu = new_mtu;
 139         return 0;
 140 }
 141
 142 struct net_device *alloc_ieee80211(int sizeof_priv)
 143 {
 144         struct ieee80211_device *ieee;
 145         struct net_device *dev;
 146         int err;
 147
 148         IEEE80211_DEBUG_INFO("Initializing...\n");
 149
 150         dev = alloc_etherdev(sizeof(struct ieee80211_device) + sizeof_priv);
 151         if (!dev) {
 152                 IEEE80211_ERROR("Unable to allocate network device.\n");
 153                 goto failed;
 154         }
 155         ieee = netdev_priv(dev);
 156         dev->hard_start_xmit = ieee80211_xmit;
 157         dev->change_mtu = ieee80211_change_mtu;
 158
 159         ieee->dev = dev;
 160
 161         err = ieee80211_networks_allocate(ieee);
 162         if (err) {
 163                 IEEE80211_ERROR("Unable to allocate beacon storage: %d\n", err);
 164                 goto failed_free_netdev;
 165         }
 166         ieee80211_networks_initialize(ieee);
 167
 168         /* Default fragmentation threshold is maximum payload size */
 169         ieee->fts = DEFAULT_FTS;
 170         ieee->rts = DEFAULT_FTS;
 171         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 172         ieee->open_wep = 1;
 173
 174         /* Default to enabling full open WEP with host based encrypt/decrypt */
 175         ieee->host_encrypt = 1;
 176         ieee->host_decrypt = 1;
 177         ieee->host_mc_decrypt = 1;
 178
 179         /* Host fragementation in Open mode. Default is enabled.
 180          * Note: host fragmentation is always enabled if host encryption
 181          * is enabled. For cards can do hardware encryption, they must do
 182          * hardware fragmentation as well. So we don't need a variable
 183          * like host_enc_frag. */
 184         ieee->host_open_frag = 1;
 185         ieee->ieee802_1x = 1;   /* Default to supporting 802.1x */
 186
 187         spin_lock_init(&ieee->lock);
 188
 189         lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
 190
 191         ieee->wpa_enabled = 0;
 192         ieee->drop_unencrypted = 0;
 193         ieee->privacy_invoked = 0;
 194
 195         return dev;
 196
 197 failed_free_netdev:
 198         free_netdev(dev);
 199 failed:
 200         return NULL;
 201 }
 202
 203 void free_ieee80211(struct net_device *dev)
 204 {
 205         struct ieee80211_device *ieee = netdev_priv(dev);
 206
 207         lib80211_crypt_info_free(&ieee->crypt_info);
 208
 209         ieee80211_networks_free(ieee);
 210         free_netdev(dev);
 211 }
 212
 213 #ifdef CONFIG_LIBIPW_DEBUG
 214
 215 static int debug = 0;
 216 u32 ieee80211_debug_level = 0;
 217 EXPORT_SYMBOL_GPL(ieee80211_debug_level);
 218 static struct proc_dir_entry *ieee80211_proc = NULL;
 219
 220 static int show_debug_level(char *page, char **start, off_t offset,
 221                             int count, int *eof, void *data)
 222 {
 223         return snprintf(page, count, "0x%08X\n", ieee80211_debug_level);
 224 }
 225
 226 static int store_debug_level(struct file *file, const char __user * buffer,
 227                              unsigned long count, void *data)
 228 {
 229         char buf[] = "0x00000000\n";
 230         unsigned long len = min((unsigned long)sizeof(buf) - 1, count);
 231         unsigned long val;
 232
 233         if (copy_from_user(buf, buffer, len))
 234                 return count;
 235         buf[len] = 0;
 236         if (sscanf(buf, "%li", &val) != 1)
 237                 printk(KERN_INFO DRV_NAME
 238                        ": %s is not in hex or decimal form.\n", buf);
 239         else
 240                 ieee80211_debug_level = val;
 241
 242         return strnlen(buf, len);
 243 }
 244 #endif                          /* CONFIG_LIBIPW_DEBUG */
 245
 246 static int __init ieee80211_init(void)
 247 {
 248 #ifdef CONFIG_LIBIPW_DEBUG
 249         struct proc_dir_entry *e;
 250
 251         ieee80211_debug_level = debug;
 252         ieee80211_proc = proc_mkdir(DRV_NAME, init_net.proc_net);
 253         if (ieee80211_proc == NULL) {
 254                 IEEE80211_ERROR("Unable to create " DRV_NAME
 255                                 " proc directory\n");
 256                 return -EIO;
 257         }
 258         e = create_proc_entry("debug_level", S_IFREG | S_IRUGO | S_IWUSR,
 259                               ieee80211_proc);
 260         if (!e) {
 261                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 262                 ieee80211_proc = NULL;
 263                 return -EIO;
 264         }
 265         e->read_proc = show_debug_level;
 266         e->write_proc = store_debug_level;
 267         e->data = NULL;
 268 #endif                          /* CONFIG_LIBIPW_DEBUG */
 269
 270         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
 271         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
 272
 273         return 0;
 274 }
 275
 276 static void __exit ieee80211_exit(void)
 277 {
 278 #ifdef CONFIG_LIBIPW_DEBUG
 279         if (ieee80211_proc) {
 280                 remove_proc_entry("debug_level", ieee80211_proc);
 281                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 282                 ieee80211_proc = NULL;
 283         }
 284 #endif                          /* CONFIG_LIBIPW_DEBUG */
 285 }
 286
 287 #ifdef CONFIG_LIBIPW_DEBUG
 288 #include <linux/moduleparam.h>
 289 module_param(debug, int, 0444);
 290 MODULE_PARM_DESC(debug, "debug output mask");
 291 #endif                          /* CONFIG_LIBIPW_DEBUG */
 292
 293 module_exit(ieee80211_exit);
 294 module_init(ieee80211_init);
 295
 296 EXPORT_SYMBOL(alloc_ieee80211);
 297 EXPORT_SYMBOL(free_ieee80211);