SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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   Intel Linux Wireless <ilw@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 "libipw.h"
  54
  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>"
  59
  60 MODULE_VERSION(DRV_VERSION);
  61 MODULE_DESCRIPTION(DRV_DESCRIPTION);
  62 MODULE_AUTHOR(DRV_COPYRIGHT);
  63 MODULE_LICENSE("GPL");
  64
  65 struct cfg80211_ops libipw_config_ops = { };
  66 void *libipw_wiphy_privid = &libipw_wiphy_privid;
  67
  68 static int libipw_networks_allocate(struct libipw_device *ieee)
  69 {
  70         int i, j;
  71
  72         for (i = 0; i < MAX_NETWORK_COUNT; i++) {
  73                 ieee->networks[i] = kzalloc(sizeof(struct libipw_network),
  74                                             GFP_KERNEL);
  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]);
  79                         return -ENOMEM;
  80                 }
  81         }
  82
  83         return 0;
  84 }
  85
  86 void libipw_network_reset(struct libipw_network *network)
  87 {
  88         if (!network)
  89                 return;
  90
  91         if (network->ibss_dfs) {
  92                 kfree(network->ibss_dfs);
  93                 network->ibss_dfs = NULL;
  94         }
  95 }
  96
  97 static inline void libipw_networks_free(struct libipw_device *ieee)
  98 {
  99         int i;
 100
 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]);
 105         }
 106 }
 107
 108 void libipw_networks_age(struct libipw_device *ieee,
 109                             unsigned long age_secs)
 110 {
 111         struct libipw_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(libipw_networks_age);
 122
 123 static void libipw_networks_initialize(struct libipw_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 int libipw_change_mtu(struct net_device *dev, int new_mtu)
 135 {
 136         if ((new_mtu < 68) || (new_mtu > LIBIPW_DATA_LEN))
 137                 return -EINVAL;
 138         dev->mtu = new_mtu;
 139         return 0;
 140 }
 141 EXPORT_SYMBOL(libipw_change_mtu);
 142
 143 struct net_device *alloc_ieee80211(int sizeof_priv, int monitor)
 144 {
 145         struct libipw_device *ieee;
 146         struct net_device *dev;
 147         int err;
 148
 149         LIBIPW_DEBUG_INFO("Initializing...\n");
 150
 151         dev = alloc_etherdev(sizeof(struct libipw_device) + sizeof_priv);
 152         if (!dev) {
 153                 LIBIPW_ERROR("Unable to allocate network device.\n");
 154                 goto failed;
 155         }
 156         ieee = netdev_priv(dev);
 157
 158         ieee->dev = dev;
 159
 160         if (!monitor) {
 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;
 165                 }
 166
 167                 ieee->dev->ieee80211_ptr = &ieee->wdev;
 168                 ieee->wdev.iftype = NL80211_IFTYPE_STATION;
 169
 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;
 174
 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);
 179         }
 180
 181         err = libipw_networks_allocate(ieee);
 182         if (err) {
 183                 LIBIPW_ERROR("Unable to allocate beacon storage: %d\n", err);
 184                 goto failed_free_wiphy;
 185         }
 186         libipw_networks_initialize(ieee);
 187
 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;
 192         ieee->open_wep = 1;
 193
 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;
 198
 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 */
 206
 207         spin_lock_init(&ieee->lock);
 208
 209         lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
 210
 211         ieee->wpa_enabled = 0;
 212         ieee->drop_unencrypted = 0;
 213         ieee->privacy_invoked = 0;
 214
 215         return dev;
 216
 217 failed_free_wiphy:
 218         if (!monitor)
 219                 wiphy_free(ieee->wdev.wiphy);
 220 failed_free_netdev:
 221         free_netdev(dev);
 222 failed:
 223         return NULL;
 224 }
 225
 226 void free_ieee80211(struct net_device *dev, int monitor)
 227 {
 228         struct libipw_device *ieee = netdev_priv(dev);
 229
 230         lib80211_crypt_info_free(&ieee->crypt_info);
 231
 232         libipw_networks_free(ieee);
 233
 234         /* free cfg80211 resources */
 235         if (!monitor)
 236                 wiphy_free(ieee->wdev.wiphy);
 237
 238         free_netdev(dev);
 239 }
 240
 241 #ifdef CONFIG_LIBIPW_DEBUG
 242
 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;
 247
 248 static int debug_level_proc_show(struct seq_file *m, void *v)
 249 {
 250         seq_printf(m, "0x%08X\n", libipw_debug_level);
 251         return 0;
 252 }
 253
 254 static int debug_level_proc_open(struct inode *inode, struct file *file)
 255 {
 256         return single_open(file, debug_level_proc_show, NULL);
 257 }
 258
 259 static ssize_t debug_level_proc_write(struct file *file,
 260                 const char __user *buffer, size_t count, loff_t *pos)
 261 {
 262         char buf[] = "0x00000000\n";
 263         size_t len = min(sizeof(buf) - 1, count);
 264         unsigned long val;
 265
 266         if (copy_from_user(buf, buffer, len))
 267                 return count;
 268         buf[len] = 0;
 269         if (sscanf(buf, "%li", &val) != 1)
 270                 printk(KERN_INFO DRV_NAME
 271                        ": %s is not in hex or decimal form.\n", buf);
 272         else
 273                 libipw_debug_level = val;
 274
 275         return strnlen(buf, len);
 276 }
 277
 278 static const struct file_operations debug_level_proc_fops = {
 279         .owner          = THIS_MODULE,
 280         .open           = debug_level_proc_open,
 281         .read           = seq_read,
 282         .llseek         = seq_lseek,
 283         .release        = single_release,
 284         .write          = debug_level_proc_write,
 285 };
 286 #endif                          /* CONFIG_LIBIPW_DEBUG */
 287
 288 static int __init libipw_init(void)
 289 {
 290 #ifdef CONFIG_LIBIPW_DEBUG
 291         struct proc_dir_entry *e;
 292
 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");
 298                 return -EIO;
 299         }
 300         e = proc_create("debug_level", S_IRUGO | S_IWUSR, libipw_proc,
 301                         &debug_level_proc_fops);
 302         if (!e) {
 303                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 304                 libipw_proc = NULL;
 305                 return -EIO;
 306         }
 307 #endif                          /* CONFIG_LIBIPW_DEBUG */
 308
 309         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
 310         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
 311
 312         return 0;
 313 }
 314
 315 static void __exit libipw_exit(void)
 316 {
 317 #ifdef CONFIG_LIBIPW_DEBUG
 318         if (libipw_proc) {
 319                 remove_proc_entry("debug_level", libipw_proc);
 320                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 321                 libipw_proc = NULL;
 322         }
 323 #endif                          /* CONFIG_LIBIPW_DEBUG */
 324 }
 325
 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 */
 331
 332 module_exit(libipw_exit);
 333 module_init(libipw_init);
 334
 335 EXPORT_SYMBOL(alloc_ieee80211);
 336 EXPORT_SYMBOL(free_ieee80211);