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        "libipw"
  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         if (ieee->networks)
  71                 return 0;
  72
  73         ieee->networks =
  74             kzalloc(MAX_NETWORK_COUNT * sizeof(struct libipw_network),
  75                     GFP_KERNEL);
  76         if (!ieee->networks) {
  77                 printk(KERN_WARNING "%s: Out of memory allocating beacons\n",
  78                        ieee->dev->name);
  79                 return -ENOMEM;
  80         }
  81
  82         return 0;
  83 }
  84
  85 void libipw_network_reset(struct libipw_network *network)
  86 {
  87         if (!network)
  88                 return;
  89
  90         if (network->ibss_dfs) {
  91                 kfree(network->ibss_dfs);
  92                 network->ibss_dfs = NULL;
  93         }
  94 }
  95
  96 static inline void libipw_networks_free(struct libipw_device *ieee)
  97 {
  98         int i;
  99
 100         if (!ieee->networks)
 101                 return;
 102
 103         for (i = 0; i < MAX_NETWORK_COUNT; i++)
 104                 if (ieee->networks[i].ibss_dfs)
 105                         kfree(ieee->networks[i].ibss_dfs);
 106
 107         kfree(ieee->networks);
 108         ieee->networks = NULL;
 109 }
 110
 111 void libipw_networks_age(struct libipw_device *ieee,
 112                             unsigned long age_secs)
 113 {
 114         struct libipw_network *network = NULL;
 115         unsigned long flags;
 116         unsigned long age_jiffies = msecs_to_jiffies(age_secs * MSEC_PER_SEC);
 117
 118         spin_lock_irqsave(&ieee->lock, flags);
 119         list_for_each_entry(network, &ieee->network_list, list) {
 120                 network->last_scanned -= age_jiffies;
 121         }
 122         spin_unlock_irqrestore(&ieee->lock, flags);
 123 }
 124 EXPORT_SYMBOL(libipw_networks_age);
 125
 126 static void libipw_networks_initialize(struct libipw_device *ieee)
 127 {
 128         int i;
 129
 130         INIT_LIST_HEAD(&ieee->network_free_list);
 131         INIT_LIST_HEAD(&ieee->network_list);
 132         for (i = 0; i < MAX_NETWORK_COUNT; i++)
 133                 list_add_tail(&ieee->networks[i].list,
 134                               &ieee->network_free_list);
 135 }
 136
 137 int libipw_change_mtu(struct net_device *dev, int new_mtu)
 138 {
 139         if ((new_mtu < 68) || (new_mtu > LIBIPW_DATA_LEN))
 140                 return -EINVAL;
 141         dev->mtu = new_mtu;
 142         return 0;
 143 }
 144 EXPORT_SYMBOL(libipw_change_mtu);
 145
 146 struct net_device *alloc_libipw(int sizeof_priv, int monitor)
 147 {
 148         struct libipw_device *ieee;
 149         struct net_device *dev;
 150         int err;
 151
 152         LIBIPW_DEBUG_INFO("Initializing...\n");
 153
 154         dev = alloc_etherdev(sizeof(struct libipw_device) + sizeof_priv);
 155         if (!dev) {
 156                 LIBIPW_ERROR("Unable to allocate network device.\n");
 157                 goto failed;
 158         }
 159         ieee = netdev_priv(dev);
 160
 161         ieee->dev = dev;
 162
 163         if (!monitor) {
 164                 ieee->wdev.wiphy = wiphy_new(&libipw_config_ops, 0);
 165                 if (!ieee->wdev.wiphy) {
 166                         LIBIPW_ERROR("Unable to allocate wiphy.\n");
 167                         goto failed_free_netdev;
 168                 }
 169
 170                 ieee->dev->ieee80211_ptr = &ieee->wdev;
 171                 ieee->wdev.iftype = NL80211_IFTYPE_STATION;
 172
 173                 /* Fill-out wiphy structure bits we know...  Not enough info
 174                    here to call set_wiphy_dev or set MAC address or channel info
 175                    -- have to do that in ->ndo_init... */
 176                 ieee->wdev.wiphy->privid = libipw_wiphy_privid;
 177
 178                 ieee->wdev.wiphy->max_scan_ssids = 1;
 179                 ieee->wdev.wiphy->max_scan_ie_len = 0;
 180                 ieee->wdev.wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
 181                                                 | BIT(NL80211_IFTYPE_ADHOC);
 182         }
 183
 184         err = libipw_networks_allocate(ieee);
 185         if (err) {
 186                 LIBIPW_ERROR("Unable to allocate beacon storage: %d\n", err);
 187                 goto failed_free_wiphy;
 188         }
 189         libipw_networks_initialize(ieee);
 190
 191         /* Default fragmentation threshold is maximum payload size */
 192         ieee->fts = DEFAULT_FTS;
 193         ieee->rts = DEFAULT_FTS;
 194         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 195         ieee->open_wep = 1;
 196
 197         /* Default to enabling full open WEP with host based encrypt/decrypt */
 198         ieee->host_encrypt = 1;
 199         ieee->host_decrypt = 1;
 200         ieee->host_mc_decrypt = 1;
 201
 202         /* Host fragmentation in Open mode. Default is enabled.
 203          * Note: host fragmentation is always enabled if host encryption
 204          * is enabled. For cards can do hardware encryption, they must do
 205          * hardware fragmentation as well. So we don't need a variable
 206          * like host_enc_frag. */
 207         ieee->host_open_frag = 1;
 208         ieee->ieee802_1x = 1;   /* Default to supporting 802.1x */
 209
 210         spin_lock_init(&ieee->lock);
 211
 212         lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
 213
 214         ieee->wpa_enabled = 0;
 215         ieee->drop_unencrypted = 0;
 216         ieee->privacy_invoked = 0;
 217
 218         return dev;
 219
 220 failed_free_wiphy:
 221         if (!monitor)
 222                 wiphy_free(ieee->wdev.wiphy);
 223 failed_free_netdev:
 224         free_netdev(dev);
 225 failed:
 226         return NULL;
 227 }
 228 EXPORT_SYMBOL(alloc_libipw);
 229
 230 void free_libipw(struct net_device *dev, int monitor)
 231 {
 232         struct libipw_device *ieee = netdev_priv(dev);
 233
 234         lib80211_crypt_info_free(&ieee->crypt_info);
 235
 236         libipw_networks_free(ieee);
 237
 238         /* free cfg80211 resources */
 239         if (!monitor)
 240                 wiphy_free(ieee->wdev.wiphy);
 241
 242         free_netdev(dev);
 243 }
 244 EXPORT_SYMBOL(free_libipw);
 245
 246 #ifdef CONFIG_LIBIPW_DEBUG
 247
 248 static int debug = 0;
 249 u32 libipw_debug_level = 0;
 250 EXPORT_SYMBOL_GPL(libipw_debug_level);
 251 static struct proc_dir_entry *libipw_proc = NULL;
 252
 253 static int debug_level_proc_show(struct seq_file *m, void *v)
 254 {
 255         seq_printf(m, "0x%08X\n", libipw_debug_level);
 256         return 0;
 257 }
 258
 259 static int debug_level_proc_open(struct inode *inode, struct file *file)
 260 {
 261         return single_open(file, debug_level_proc_show, NULL);
 262 }
 263
 264 static ssize_t debug_level_proc_write(struct file *file,
 265                 const char __user *buffer, size_t count, loff_t *pos)
 266 {
 267         char buf[] = "0x00000000\n";
 268         size_t len = min(sizeof(buf) - 1, count);
 269         unsigned long val;
 270
 271         if (copy_from_user(buf, buffer, len))
 272                 return count;
 273         buf[len] = 0;
 274         if (sscanf(buf, "%li", &val) != 1)
 275                 printk(KERN_INFO DRV_NAME
 276                        ": %s is not in hex or decimal form.\n", buf);
 277         else
 278                 libipw_debug_level = val;
 279
 280         return strnlen(buf, len);
 281 }
 282
 283 static const struct file_operations debug_level_proc_fops = {
 284         .owner          = THIS_MODULE,
 285         .open           = debug_level_proc_open,
 286         .read           = seq_read,
 287         .llseek         = seq_lseek,
 288         .release        = single_release,
 289         .write          = debug_level_proc_write,
 290 };
 291 #endif                          /* CONFIG_LIBIPW_DEBUG */
 292
 293 static int __init libipw_init(void)
 294 {
 295 #ifdef CONFIG_LIBIPW_DEBUG
 296         struct proc_dir_entry *e;
 297
 298         libipw_debug_level = debug;
 299         libipw_proc = proc_mkdir("ieee80211", init_net.proc_net);
 300         if (libipw_proc == NULL) {
 301                 LIBIPW_ERROR("Unable to create " DRV_NAME
 302                                 " proc directory\n");
 303                 return -EIO;
 304         }
 305         e = proc_create("debug_level", S_IRUGO | S_IWUSR, libipw_proc,
 306                         &debug_level_proc_fops);
 307         if (!e) {
 308                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 309                 libipw_proc = NULL;
 310                 return -EIO;
 311         }
 312 #endif                          /* CONFIG_LIBIPW_DEBUG */
 313
 314         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
 315         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
 316
 317         return 0;
 318 }
 319
 320 static void __exit libipw_exit(void)
 321 {
 322 #ifdef CONFIG_LIBIPW_DEBUG
 323         if (libipw_proc) {
 324                 remove_proc_entry("debug_level", libipw_proc);
 325                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 326                 libipw_proc = NULL;
 327         }
 328 #endif                          /* CONFIG_LIBIPW_DEBUG */
 329 }
 330
 331 #ifdef CONFIG_LIBIPW_DEBUG
 332 #include <linux/moduleparam.h>
 333 module_param(debug, int, 0444);
 334 MODULE_PARM_DESC(debug, "debug output mask");
 335 #endif                          /* CONFIG_LIBIPW_DEBUG */
 336
 337 module_exit(libipw_exit);
 338 module_init(libipw_init);