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         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_ieee80211(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 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))
 161         dev->hard_start_xmit = libipw_xmit;
 162         dev->change_mtu = libipw_change_mtu;
 163 #endif
 164
 165         ieee->dev = dev;
 166
 167         if (!monitor) {
 168                 ieee->wdev.wiphy = wiphy_new(&libipw_config_ops, 0);
 169                 if (!ieee->wdev.wiphy) {
 170                         LIBIPW_ERROR("Unable to allocate wiphy.\n");
 171                         goto failed_free_netdev;
 172                 }
 173
 174                 ieee->dev->ieee80211_ptr = &ieee->wdev;
 175                 ieee->wdev.iftype = NL80211_IFTYPE_STATION;
 176
 177                 /* Fill-out wiphy structure bits we know...  Not enough info
 178                    here to call set_wiphy_dev or set MAC address or channel info
 179                    -- have to do that in ->ndo_init... */
 180                 ieee->wdev.wiphy->privid = libipw_wiphy_privid;
 181
 182                 ieee->wdev.wiphy->max_scan_ssids = 1;
 183                 ieee->wdev.wiphy->max_scan_ie_len = 0;
 184                 ieee->wdev.wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
 185                                                 | BIT(NL80211_IFTYPE_ADHOC);
 186         }
 187
 188         err = libipw_networks_allocate(ieee);
 189         if (err) {
 190                 LIBIPW_ERROR("Unable to allocate beacon storage: %d\n", err);
 191                 goto failed_free_wiphy;
 192         }
 193         libipw_networks_initialize(ieee);
 194
 195         /* Default fragmentation threshold is maximum payload size */
 196         ieee->fts = DEFAULT_FTS;
 197         ieee->rts = DEFAULT_FTS;
 198         ieee->scan_age = DEFAULT_MAX_SCAN_AGE;
 199         ieee->open_wep = 1;
 200
 201         /* Default to enabling full open WEP with host based encrypt/decrypt */
 202         ieee->host_encrypt = 1;
 203         ieee->host_decrypt = 1;
 204         ieee->host_mc_decrypt = 1;
 205
 206         /* Host fragmentation in Open mode. Default is enabled.
 207          * Note: host fragmentation is always enabled if host encryption
 208          * is enabled. For cards can do hardware encryption, they must do
 209          * hardware fragmentation as well. So we don't need a variable
 210          * like host_enc_frag. */
 211         ieee->host_open_frag = 1;
 212         ieee->ieee802_1x = 1;   /* Default to supporting 802.1x */
 213
 214         spin_lock_init(&ieee->lock);
 215
 216         lib80211_crypt_info_init(&ieee->crypt_info, dev->name, &ieee->lock);
 217
 218         ieee->wpa_enabled = 0;
 219         ieee->drop_unencrypted = 0;
 220         ieee->privacy_invoked = 0;
 221
 222         return dev;
 223
 224 failed_free_wiphy:
 225         if (!monitor)
 226                 wiphy_free(ieee->wdev.wiphy);
 227 failed_free_netdev:
 228         free_netdev(dev);
 229 failed:
 230         return NULL;
 231 }
 232
 233 void free_ieee80211(struct net_device *dev, int monitor)
 234 {
 235         struct libipw_device *ieee = netdev_priv(dev);
 236
 237         lib80211_crypt_info_free(&ieee->crypt_info);
 238
 239         libipw_networks_free(ieee);
 240
 241         /* free cfg80211 resources */
 242         if (!monitor)
 243                 wiphy_free(ieee->wdev.wiphy);
 244
 245         free_netdev(dev);
 246 }
 247
 248 #ifdef CONFIG_LIBIPW_DEBUG
 249
 250 static int debug = 0;
 251 u32 libipw_debug_level = 0;
 252 EXPORT_SYMBOL_GPL(libipw_debug_level);
 253 static struct proc_dir_entry *libipw_proc = NULL;
 254
 255 static int debug_level_proc_show(struct seq_file *m, void *v)
 256 {
 257         seq_printf(m, "0x%08X\n", libipw_debug_level);
 258         return 0;
 259 }
 260
 261 static int debug_level_proc_open(struct inode *inode, struct file *file)
 262 {
 263         return single_open(file, debug_level_proc_show, NULL);
 264 }
 265
 266 static ssize_t debug_level_proc_write(struct file *file,
 267                 const char __user *buffer, size_t count, loff_t *pos)
 268 {
 269         char buf[] = "0x00000000\n";
 270         size_t len = min(sizeof(buf) - 1, count);
 271         unsigned long val;
 272
 273         if (copy_from_user(buf, buffer, len))
 274                 return count;
 275         buf[len] = 0;
 276         if (sscanf(buf, "%li", &val) != 1)
 277                 printk(KERN_INFO DRV_NAME
 278                        ": %s is not in hex or decimal form.\n", buf);
 279         else
 280                 libipw_debug_level = val;
 281
 282         return strnlen(buf, len);
 283 }
 284
 285 static const struct file_operations debug_level_proc_fops = {
 286         .owner          = THIS_MODULE,
 287         .open           = debug_level_proc_open,
 288         .read           = seq_read,
 289         .llseek         = seq_lseek,
 290         .release        = single_release,
 291         .write          = debug_level_proc_write,
 292 };
 293 #endif                          /* CONFIG_LIBIPW_DEBUG */
 294
 295 static int __init libipw_init(void)
 296 {
 297 #ifdef CONFIG_LIBIPW_DEBUG
 298         struct proc_dir_entry *e;
 299
 300         libipw_debug_level = debug;
 301         libipw_proc = proc_mkdir(DRV_NAME, init_net.proc_net);
 302         if (libipw_proc == NULL) {
 303                 LIBIPW_ERROR("Unable to create " DRV_NAME
 304                                 " proc directory\n");
 305                 return -EIO;
 306         }
 307         e = proc_create("debug_level", S_IRUGO | S_IWUSR, libipw_proc,
 308                         &debug_level_proc_fops);
 309         if (!e) {
 310                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 311                 libipw_proc = NULL;
 312                 return -EIO;
 313         }
 314 #endif                          /* CONFIG_LIBIPW_DEBUG */
 315
 316         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
 317         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
 318
 319         return 0;
 320 }
 321
 322 static void __exit libipw_exit(void)
 323 {
 324 #ifdef CONFIG_LIBIPW_DEBUG
 325         if (libipw_proc) {
 326                 remove_proc_entry("debug_level", libipw_proc);
 327                 remove_proc_entry(DRV_NAME, init_net.proc_net);
 328                 libipw_proc = NULL;
 329         }
 330 #endif                          /* CONFIG_LIBIPW_DEBUG */
 331 }
 332
 333 #ifdef CONFIG_LIBIPW_DEBUG
 334 #include <linux/moduleparam.h>
 335 module_param(debug, int, 0444);
 336 MODULE_PARM_DESC(debug, "debug output mask");
 337 #endif                          /* CONFIG_LIBIPW_DEBUG */
 338
 339 module_exit(libipw_exit);
 340 module_init(libipw_init);
 341
 342 EXPORT_SYMBOL(alloc_ieee80211);
 343 EXPORT_SYMBOL(free_ieee80211);